The TAA Productivity Tools are updated periodically for new tools,
enhancements, and fixes. New versions are shipped a few times per
year.
This document combines the refresh notes that were previously in
separate documents for new tools, enhanced tools, fixes, and
incompatibilities. The document is organized by refresh with the most
recent refresh listed first.
All refreshes since V5R2 are included.
2026-10-15 (T104)
Refresh T104 (October 15, 2026) is for IBM i 7.3, 7.4, 7.5, and 7.6.
End of Service Statements
No further refreshes or fixes will be made for IBM i 7.2 or earlier
releases.
IBM's first extended support period for IBM i 7.3 ends on September
30, 2026. T104 is the last refresh that will be issued for 7.3. No
fixes or refreshes will be available for 7.3 after T104.
New Tools
- DLTIFS3
The DLTIFS3 command allows deletion of one or more IFS objects in a
directory and all its subdirectories based on selection criteria
such as name, size, last changed date, and others.
DLTIFS3 differs from the DLTIFS and DLTIFS2 in that it uses a
recursive approach to find, analyze, and delete objects in the IFS.
This is a powerful command and so comes with some restrictions on
the types of objects involved.
Enhancements
- CHGLBLJOBD
The Change Library List from Job Description command now has a
completion message in the job log that includes the name of the job
description used.
- CHKOBJDMG
The Check Object Damage command has a new data compression keyword,
DTACPR, that can take *ZLIB as a value. This causes the checked
objects to be saved with ZLIB compression if your system supports
that. This is useful if the library you are checking contains large
files that would hit the limits of the SAVOBJ command.
- CVTDTAQ
The Convert Data Queue command has been enhanced to allow for
entries up to 10,000 bytes in length. This will generate an outfile
based on the model file TAATOOL/TAADTQMP2 instead of TAADTQMP.
TAADTQMP will continue to be used for data queues with entries up to
5000 bytes in length.
- DLTIFS
A new keyword was added to DLTIFS and DLTIFS2 that suppresses the
escape message when no objects met the criteria. A completion
message is issued instead.
- DSPFMT
A wide screen option has been added to the Display Format tool. The
wide screen shows the alias names and the column headings for the
fields on the primary display screen.
- INZPWD3
A new value of *SYSVAL was added for the PWDLEN parameter and made
the default. New passwords created by INZPWD3 will be the minimum
length allowed by the system values that control the password. Also
a new keyword (OUTPUT) was added that can send the new password to
the caller. This is used by the SECOFR2 menu.
- RTVDAT3
Retrieve Date 3 has been enhanced to easily retrieve a day in the
current month using *CURRENT. For example, you can now get quick
access to the last Sunday or Friday of the current month.
- SECOFR2
INZPWD3 was added as an optional replacement for the INZPWD2 command
used by option 3 on the SECOFR2 menu. INZPWD3 will always create a
password that respects the system rules, whereas INZPWD2 may create
a simpler password. If *ALLCRTCHG is specified then INZPWD2 will
also respect the password rules. See the documentation for INZPWD2
and INZPWD3 commands in the INZPWD tool.
- SPLARC
The WRKSPLARC command of the SPLARC tool can restore a spooled file
from the archive, but if the archive was saved to tape and later
moved to a save file WRKSPLARC could not restore it. This
enhancement adds a prompt that let's users identify the proper save
file.
- WRKJOB2
Work with Jobs 2 has been enhanced to include a filter for the job
submitter in addition to all the other new filters added in recent
refreshes.
Fixes
- CHGOBJAUT
CHGOBJAUT would sometimes get an error about attempting to open an
already open printer file. It was changed to use the PRINT2 tool to
avoid this.
- CHKSECADM
The Check for Security Admin special authority command ran into an
issue on 7.6 when the job user was one of the new non-changing
profiles such as QUSER_NC. This was fixed.
- CLRMSGQ2
The Clear Message Queue 2 command would sometimes fail if the number
of messages exceeded a limit. A different API is now used that
removes that limit.
- CLROUTQ3
Clear Output Queue 3 would fail when there were too many files of
the same name and job in a queue. This would typically happen with
job logs. This was due to older version of the code that used four
digit spooled file numbers. This has been fixed to use the six digit
ones.
- CPYMSGQ
Copy Message Queue would fail if all of the following were true.
- A program message found in the queue was one with a message
description found in a message file.
- The sending program referenced the message file using the library
list.
- CPYMSGQ was issued from a job that did not have that message file
in its library list. CPYMSGQ will now issue an escape message
explaining the recovery procedure if this is the case.
- CVTENVVAR
Convert Environment Variables was fixed to properly convert empty
strings.
- DUPSPLF
Duplicate Spooled File was not copying the user defined text
attribute. This has been added to the tool.
- PRINT
The PRINT2 command of the PRINT tool was changed to user open for
the printer file. This was made in conjunction with the fix to
CHGOBJAUT.
- WRKALLSPLF
Work With All Spooled Files was not checking properly for *JOBCTL
authority. That has been fixed.
Changes to output files
There are no changes to output file formats in this refresh. Work has
been confined to fixes and 7.6 support.
Incompatibilities
There are no known incompatibilities in this refresh. ## 2025-08-15
(T103)
Refresh T103 (August 15, 2025) is for IBM i 7.3, 7.4, 7.5, and 7.6.
No further refreshes or fixes will be made for IBM i 7.2 or earlier
releases.
HIPER news
The Retrieve Object List (RTVOBJLST) is a tool used by several other
tools. Recent IBM PTFs on V7R4 and V7R5 have some enhanced parameter
checking that exposed an issue in the tools usage of the QUSLOBJ API.
This shows up as a "Status value ? not valid" error in the job log. It
has been reported most often while using the DLTOLDSPLF tool. This was
fixed in T102 and T103 for all supported releases. There is also a
patch available for all releases.
See https://taatool.com/fixes/0003/readme.html for more information.
IBM i 7.6 Notes
This is the first refresh that contains support for IBM i 7.6.
New Tools
- CVTOWNOBJ
The Convert Owned Objects tool is similar to the system DSPUSRPRF
TYPE(*OBJOWN) with an outfile, but provides substantially more
information.
Enhancements
- CHG128PWD
There was an issue with the CHG128PWD tool used to replicate
passwords between systems. This tool relies on the
QIBM_QSY_VLD_PASSWRD exit point and installs a user-defined program
to encrypt the new password for replication. This was running into a
CCSID issue when a changed password was entered in the ACS login
window. The tool was enhanced to handle the CCSID used by ACS.
- TRCDBG
The STRTRCDBG command of the Trace Debug tool has been enhanced to
allow for up to 99,999,999 statements to be traced.
- WRKJOB2
The Work With Jobs 2 command has been enhanced to include more
information such as completion time. There are now two views that
you can toggle between using F11.
Fixes
- CAPPTFINF
The CMPPTFINF command of the CAPPTFINF tool had a bug in its date
handling in the FROMVER and TOVER keywords when specific dates were
used rather than the defaults. This has been fixed in T103.
- PRINT
An update to the PRINT tool in T102 inadvertently caused extra empty
spooled files to be created. The PRINT tool is used by other tools
and you may see these files as a result. This has been fixed in
T103.
- RMVMSGQMSG
There were circumstances when the Remove Message Queue Message tool
would attempt to log a very long message informational to the job
log. This has been fixed so that the message stays within
appropriate bounds.
Changes to output files
There are no changes to output file formats in this refresh. Work has
been confined to fixes and 7.6 support.
Incompatibilities
- Commands that refer to previous releases (7.6 only)
All save commands, most compile commands, and commands that use *PRV
compiler support have had their TGTRLS parameters updated for 7.6.
While technically incompatible with previous release this is
consistent with IBM i 7.6 changes. The following commands have been
affected:
---------------------------------------------------------------------------
Tool Command Description
------------ ------------ -------------------------------------------------
CHKPGMRLS CHKPGMRLS Check Program Release - CHKPGMRLS
CHKTGTRLS CHKTGTRLS Check Target Release - CHKTGTRLS
CMPOUTFILE CMPOUTFILE Compare System Outfiles - CMPOUTFILE
CRTBNDCL2 CRTBNDCL2 Create Bound CL Pgm 2 - CRTBNDCL2
CRTBNDRPG2 CRTBNDRPG2 Create Bound RPG Pgm 2 - CRTBNDRPG2
CRTSFLPGM CRTSFLPGM Create Subfile Program - CRTSFLPGM
CRTSFLPGM RPLSFLPGM Replace Subfile Program - RPLSFLPGM
CRTSFLPGM2 CRTSFLPGM2 Create Subfile Program 2 - CRTSFLPGM2
CRTTGTRLS CRTTGTRLS Create Target Release - CRTTGTRLS
RPLGENPGM RPLGENPGM Replace Generic Programs - RPLGENPGM
RPLMOD RPLMOD Replace Module - RPLMOD
RPLOBJ RPLOBJ Replace Object - RPLOBJ
RPLPGM RPLPGM Replace Program - RPLPGM
SAVACT SAVALLACT Save All Active - SAVALLACT
SAVACT SAVCHGACT Save Changed Active - SAVCHGACT
SAVJRNRCV SAVJRNRCV Save Journal Receivers - SAVJRNRCV
SAVLIBIFS SAVLIBIFS Save Library to IFS - SAVLIBIFS
SAVOBJIFS SAVOBJIFS Save Object to IFS - SAVOBJIFS
SAVONELIB SAVONELIB Save One Library - SAVONELIB
SAVOWNOBJ SAVOWNOBJ Save Owned Objects - SAVOWNOBJ
SAVRCVL SAVRCVL Save and Receive Library with FTP - SAVRCVL
SAVRCVL SBMSAVRCVL Submit Save and Receive Lib with FTP - SBMSAVRCVL
SAVSNDL SAVSNDL Save and Send Library with FTP - SAVSNDL
SAVSNDL SBMSAVSNDL Submit Save and Send Lib - SBMSAVSNDL
SAVSNDM SAVSNDM Save and Send Member with FTP- SAVSNDM
SAVSRCF SAVSRCF Save Source Files - SAVSRCF
SNDOBJMAIL SNDOBJMAIL Send Object Mail - SNDOBJMAIL
---------------------------------------------------------------------------
2025-04-15 (T102)
Refresh T102 (April 15, 2025) is for IBM i 7.3, 7.4, and 7.5.
No further refreshes or fixes will be made for IBM i 7.2 or earlier
releases.
IBM i 7.5 Notes
See the previous release notes for IBM i 7.5 changes that affected the
tools.
New Tools
- CLCDLY
The Calculate Delay command will calculate the number of seconds
needed to delay a job for a repeating activity. It is meant to be
used with DLYJOB. It allows you to define a block of time during
which the activity must take place. It allows for that block to be
overnight if that is necessary.
Enhancements
- CHKACTUSR
Check Active User was shipped as *PUBLIC *EXCLUDE. This has been
relaxed to *PUBLIC *USE since the tool explicitly checks for *JOBCTL
authority.
- CHKACTUSR2
Check Active User 2 was shipped as *PUBLIC *EXCLUDE. This has been
relaxed to *PUBLIC *USE since the tool explicitly checks for *JOBCTL
authority.
- CHKHOLIDAY
Juneteenth has been added to the Check Holidays tool.
- CPYSRCFIFS
A new CASE keyword was added to control the case of folder and
stream file names in the IFS.
- CPYTOCSV
You can now do STMFOPT(*ADD) to add the result to an existing stream
file.
- CRTEXTPRTF
The Create External Printer File has been updated to include the
SQLRPGLE source types.
- DSPFCNUSG2
The Display Function Usage 2 command was updated. You can now invoke
it from QCMDEXC.
- DSPHOLIDAY
Juneteenth has been added to the Display USA Holidays tool.
- RTVHOLIDAY
Juneteenth has been added to the Retrieve Holiday Date tool.
Fixes
- Install
The Convert TAA Format command is used at the end of the install
process to reformat very old versions of some files used by the
SPLSTO and SPLARC tools. We've added further checks to the install
process to avoid attempting to reformat impersonators.
- CHGOBJAUT
The Change Object Authority command uses the PRINT tool internally.
There are rare situations where the CHGOBJAUT does not close that
printer file. That file is now closed on the next run if it was left
open.
- CHKCPPQSYS
The Check CPP use of QSYS command was not handling *REXX procedures
properly. It now recognizes and skips commands that have a REXX
procedure as a command processor.
- CPYTOCSV
A note was added to the documentation stating that 8-byte binary
integers show up as 0 in the resulting CSV file. Extra heading
columns were being generated if COLHDG(*FLDNAM) was being used. This
has been fixed.
- CVTOUTQ
T101 introduced a bug in Convert Output Queue that would sometimes
skip files that had identical job names, spool file names and
numbers. This can happen when job numbers wrap. This bug has been
fixed.
- CVTSYSVAL
The CVTSYSVAL command could fail with a parameter length mismatch
when attempting to retrieve the QSSLCSL system value on some
systems. This is a rare occurence. The receiver is now allocated at
the proper size.
- CVTTAAFMT
The Convert TAA Format command is used to reformat very old versions
of some files used by the SPLSTO and SPLARC tools. It was mistakenly
attempting to reformat files created with the QUSRTOOL versions of
these tools. Those files will now be excluded.
- DLTOLDSPLF
Delete Old Spooled Files was affected by the bug in CVTOUTQ. No
change was made to DLTOLDSPLF, but the CVTOUTQ bug could show up in
the DLTOLDSPLF results.
- DSPMSGQINQ
The Display Message Queue Inquiries could fail for very large
message queues. The tool was modified to be able to retrieve message
queue entries using CVTMSGQ2 which fixes the problem.
- DSPSBSJOBQ
The Display Subsystem Job Queues command could sometimes report an
array index violation. This has been fixed.
- MRGSPLF
The Merge Spool File tool has been updated to handle the case where
there are multiple files in the queue being merged that have the
same job name, spooled file name, and spooled file number. This
situation can happen when job numbers wrap from 999999 to 000000.
- RMVOLDMSG
The Remove Old Messages from MSGQs command has been rewritten to
avoid a looping condition if there were too many messages in a
queue. It has also been enhanced to allow for the deletion of "same
day" messages -- essentially clearing the message queue.
- RSNALLMSG
Resend All Messages was rewritten to properly send messages to the
using program's calling program even if the using program was an ILE
program.
- RTVIFSED
The Retrieve IFS Entry Description tool is used by several IFS tools
such as DLTIFS and CVTIFS. It had a very slow memory leak that
showed up if the number of IFS entries being examine was extremely
large. The leak has been plugged in this refresh.
- RTVOBJLST
Retrieve Object List is a tool used by several other tools. Recent
IBM PTFs on V7R5 have some enhanced parameter checking that exposed
a bug in our usage of the QUSLOBJ API. This shows up as a "Status
value ? not valid" error in the job log. This has been fixed for all
supported releases.
- RTVSYSVALA
The Retrieve System Value Attributes command was returning a length
of 1280 for the QSSLCSL value. This has been corrected to 3840.
- SNDSPLMAIL
If a mailing list created with the MAILADR tool was being used then
the Send Spooled File E-Mail tool would send to just the first *TO
address in the list. This was fixed to send to all the addresses in
the list.
- WRKALLSPLF
The Work with All Spooled Files tool could occasionally not display
some spooled files if the queues involved were too large. The tool
has been redesigned and rewritten to avoid this issue.
Changes to output files
Incompatibilities
There are no known incompatibilities in this refresh.
2024-01-15 (T101)
Refresh T101 (January 15, 2024) is for IBM i 7.3, 7.4, and 7.5.
No further refreshes will be made for IBM i 7.2. However, fixes to 7.2
tools will continue to be supplied on an "as needed" basis until April
30, 2024.
No further refreshes or fixes will be made for IBM i 7.1 or earlier
releases.
IBM i 7.5 Notes
IBM has made a couple of changes in IBM i 7.5 that affect the results
returned to the tools. The tools have been modified to accomodate
these changes. You will have issues on IBM i 7.5 with CVTEDTD,
CVTIFSAUT2, and DSPIFSOWN and tools that depend on them until you
install this refresh. See the notes for the individual tools below.
- CVTEDTD was affected by a spooled file output change.
- While not technically incompatible the QSYLOBJA API now reports IFS
path data in CCSID 1200 rather than the job CCSID. CVTIFSAUT2 and
DSPIFSOWN were affected by this change. CVTIFSAUT2 is used by
RVKIFSAUT, RVKIFSPGP, RNMIFSAUT, and RNMIFSPGP.
- It should also be noted that the CVTIFSOWN command also uses
QSYLOBJA. Since the reporting CCSID is included in the CVTIFSOWN
output, the path name data in the output file is also reported in
this CCSID. If are using CVTIFSOWN you may need to make changes to
convert from the reported CCSID.
Refresh Names
We are adopting a new scheme for naming our refreshes. Our Rxx
numbering was being confused with IBM's numbering of their releases.
Refreshes are now named Tnnn, beginning with T101, this refresh. The T
is either for "Tools" or "TAA" depending on your preference. We hope
this makes things a bit less confusing.
The numbering of previous refreshes in our release notes will remain
the same.
New Tools
There are no new tools in this refresh. There are some new ones
planned for the next refresh.
Enhancements
- CVTDEVPRT
The output file for Convert Device Printer command has a new field
for the last activity date added to the end of the record format.
This can be useful if you have a large number of printers to track
down the ones that are no longer being used.
- CVTIFSOWN
Convert IFS Owners has been updated as described in our newsletter
to convert path names on IBM i 7.5 from CCSID 1200 to the job CCSID
so that they are more compatible with previous TAATOOL refreshes and
IBM i releases.
- CVTMSGQ
Convert Message Queue had a restriction that limited it to about
30,000 messages. This limit has been removed.
- DSPJOBLOG3
The Display Job Log 3 tool has a new REFRESH keyword that is used to
view all the messages in the current job in a more convenient form
than that provided by F10 or by DSPJOBLOG. Try it with
DSPJOBLOG3 REFRESH(*YES).
- DSPRCDLCK2
The Display Record Locks 2 command would complain about duplicate
job names if duplicates existed even if only one of the duplicates
was in active state. Since record locks can only exist in active
jobs, the tool was enhanced to look for duplicates only in active
jobs rather than all jobs.
- DUPFILFMT
Duplicate File Format is extended to remove some limits on the file
being created. This is important for RTVDLTRCD to handle extremely
large files.
- RTVDEVPRT
The Retrieve Device Printer command has a new keyword for the last
activity date.
- RTVDLTRCD
Retrieve Deleted Records was enhanced to allow for much larger files
than it previously handled. See also DUPFILFMT enhancements needed
for RTVDLTRCD.
- WRKJOB2
WRKJOB2 now includes the completion date and time as the last column
of the display for jobs in *OUTQ status.
- WRKJOBSTS
Option 5 now does a WRKJOB immediately rather than prompting.
Disconnect has moved from Option 7 to Option 13 to be consistent
with WRKACTJOB.
Fixes
- ANZOUTQ
The Analyze Output Queue could run out of array space for very large
queues. The tool now stops recording unique values in each section
after 9998 have been found so the arrays never overflow.
- CHGUSRPWD3
The CHGUSRPWD3 command did not monitor for the possible CPD escape
messages sent by the APIs. The command now monitors for those.
- CHKINACT
The Check Inactive Job Timeout tool would ignore a *ALL *ALL entry
if one was entered using WRKINACT. This entry is no longer ignored.
This has the effect of overriding the default action stored in the
application value TAASECURE/CHKINACT. If such an entry is not
present then the application value becomes the default.
- CMPJRNIMG2
The tool was incorrectly checking for a limit of 199 on the number
of fields. This has been corrected to 998.
- CPYSRCFIFS
CPYSRCFIFS did not issue reasonable error messages if the user was
not authorized to the source file. New error messages have been
added.
- CPYUSRPRF2
Copy User Profile 2 is used on the SECOFR2 menu option 7. Code from
the SECOFR2 menu was moved to the prompt override program to avoid a
security exception when using option 7.
- CVTCFGSTS
This tool would fail if executed in a server job such as one running
SQL Scripts in ACS. This has been fixed.
- CVTIFSOWN
There was a change in the IBM i 7.5 IFS APIs that returns path names
in CCSID 1200 which is a UTF-16 CCSID. The code in CVTIFSOWN now
takes the path name CCSID into account and converts it to the job
CCSID for display and for use in commands.
- CVTNETSTAT
The CVTNETCNN command of the CVTNETSTAT tool was failing when there
was a large number of connections. The limits have been increased
and the problem fixed.
- CVTOUTQ
CVTOUTQ could receive a CPF3C44 exception if the output queue being
converted had been moved from one ASP to another. CPF3C44 indicates
that the internal spool id for a spooled file is no longer valid.
CVTOUTQ was changed to not rely on internal spool ids. In addition
CVTOUTQ could receive a CPF3C43 exception if the internal job id was
no longer valid. This has been fixed.
- DLTIFS
The DLTIFS command would not delete files if the file name contained
trailing blanks. This has been corrected.
- DLTOLDQRPL
The DLTOLDQRPL command would send an escape message if the total
size of the objects remaining in QRPL exceeded 99,999,999,999 bytes.
This has been increased.
- DSPALLSAVF
The DSPALLSAVF command would not work when used from the FNDCMD
list. This was due to conflicting overrides which have been fixed.
- DSPDLTSPC
There was a possibility receiving a library not found message if the
time between gathering the list of libraries and examining them was
large enough for the library to be deleted in the interim. An
additional test was added so that the timing window is now much
smaller.
- DSPJOBLOG3
The Display Job Log 3 tool would occasionally get lost when viewing
large job log spooled files. The tool has been rewritten to avoid
this issue.
- DSPJOBLOG5
The Display Job Log 5 tool will filter just the last escape message
and its related messages from a spooled job log file. If the job log
being analyzed was too long this would fail with an array indexing
error. This has been fixed.
- DSPJOBSCDC
The Display Job Scheduler Calendar would fail with an exception if a
*WEEKLY entry had *NONE for the days. This circumstance would be
unusual, but valid. This has been fixed.
- DSPMSG2
The Display Message 2 had an issue with filtering messages when used
with explicit start and end times. This has been fixed.
- DSPOBJD3
Display Object Description 3 allows for the examination of all
libraries for objects. It would fail if the number of libraries
examined was over 999. The limit has been extended.
- DSPPWDLMT
Display Password Limit was not using the time and date ranges
specified on the command. This has been fixed.
- DSPTAACAT
DSPTAACAT would fail in Refresh R73 since we finally exceeded the
array length for the number of tools in the product. We should have
caught this one before shipping. Mea culpa.
- GENRANPWD2
GENRANPWD2 would accidentally modify the PWDLEN parameter when used
due to a parameter mismatch. This has been fixed.
- MOVSPLF
MOVSPLF could fail in the cases where job numbers wrap so there are
two identical job names with the same spooled file with the same
spooled file number. While unlikely, this can happen when there are
report jobs that are run every day for years. MOVSPLF will now pick
one of those files instead of failing.
- RMVMSGQMS2
Remove Message Queue Message 2 would fail if examining multiple
queues and a queue was deleted after the list of queues was
constructed. Any queues not found are now just skipped.
- RTVFLDDTA
Retrieve Field Data would get a CPF0006 if run a second time before
finalization. This was due to a working variable holding a
constructed CHKOBJ command not being initialized. This has been
fixed.
- RTVJOBA2
The RTVJOBA2 command could fail in circumstances with a subscripting
error when the information to be retrieved was too long for the area
allocated. The area has been extended to handle that case.
- RTVSPLSIZ
The Retrieve Spool Size tool could run out of room in a temporary
file when working with a very large QSPL library. This would result
in messages to QSYSOPR and possible cancellation. The maximum number
of records in this temporary file has been increased substantially.
- SECOFR2
Code from the SECOFR2 menu was moved to the prompt override program
of CPYUSRPRF2 to avoid a security exception when using option 7.
Changes to output files
- CVTDEVPRT
The outfile for CVTDEVPRT has been modified to add a new field to
the end of the record format. Outfiles from previous versions of the
tool may need to be deleted. The tool will re-create these on first
use.
Incompatibilities
There are no known incompatibilities in this refresh.
2022-06-15 (R73)
Refresh 73 (June 15, 2022) is for IBM i 7.3, 7.4, and 7.5.
No further refreshes will be made for IBM i 7.2. However, fixes to 7.2
tools will continue to be supplied on an "as needed" basis until April
30, 2024.
No further refreshes or fixes will be made for IBM i 7.1 or earlier
releases.
IBM i 7.5 Notes
IBM has made a couple of changes in IBM i 7.5 that affect the results
returned to the tools. The tools have been modified to accomodate
these changes. If you are migrating from a previous IBM i release such
as 7.3 or 7.4 you should update your tools to refresh R73 prior to the
upgrade. If you do not update your tools you will have issues with the
CVTEDTD, CVTIFSAUT2, and DSPIFSOWN and tools that depend on them. See
the notes for the individual tools below.
CVTEDTD was affected by a spooled file output change.
While not technically incompatible the QSYLOBJA API now reports IFS
path data in CCSID 1200 rather than the job CCSID. CVTIFSAUT2 and
DSPIFSOWN were affected by this change. CVTIFSAUT2 is used by
RVKIFSAUT, RVKIFSPGP, RNMIFSAUT, and RNMIFSPGP.
It should also be noted that the CVTIFSOWN command also uses QSYLOBJA.
Since the reporting CCSID is included in the CVTIFSOWN output, the
path name data in the output file is also reported in this CCSID. If
are using CVTIFSOWN you may need to make changes to convert from the
reported CCSID.
Architecture Changes
Source Code Packaging
We are changing the way tools are packaged as source files.
Each tool has a "builder", a set of commands that is used by
CRTTAATOOL that are used to build the tool from its source code. These
builders were packaged in monolithic programs used by CRTTAATOOL. We
are now packaging these builders with the tool itself.
Likewise the command help for a tool was packaged with the command
help for other tools in large panel groups. Now the command help will
be packaged in a separate panel group and packaged with each tool.
The intent of these changes is to make the tools a bit more
self-contained so that enhancements can be made more easily.
These changes will be made over time to existing tools and will have
no external effects other than you may see extra members if you unpack
the source for a tool.
Use of the ILE Program Model
Many of the tools existed prior to the introduction of the ILE program
model. As tools are modified for fixes and enhancements we may elect
to convert them to the ILE program model.
All new tools will be written to the ILE program model. In addtion,
all new RPGLE code will be written as fully free-format.
The intent of this change is to make the future creation and
modification of tools more robust.
These should be no external effects of these changes.
New Tools
- CPYSRCFIFS
This tool will copy selected members of source files in a library
into the IFS. It is meant to provide an easy way to populate an IFS
directory from source physical files. You may wish to do this if
comparing sources across systems or when you wish to establish a
source directory usable with Source Control Management tool that
operates on Unix or Windows style directories.
- RUNTAABLDR
This command will compile and run a builder program for a tool. All
new tools are written with these builder programs, allowing them to
be easily patched onto existing systems.
Enhancements
- CPYFRMCSV
Copy From Comma Separated Values tool has two commands: CPYFRMCSV
and CPYFRMCSV2. Both were enhanced to allow DOC objects to be used
in addition to STMF object in the FROMSTMF keyword. The commands
also now allow using a | as a field separator character.
- CPYSPLFIFS
Copy Spooled File to IFS would create the spooled file with
AUT(NONE) if the PDF option was used. This was changed to use the
authorities of the containing directory similar to the system's
CPYSPLF.
- CPYUSRPRF2
The Copy User Profile 2 command would not allow a user profile to be
created if ALLCRTCHG was specified in the QPWDRULES system value.
This restriction has been removed. If ALLCRTCHG is specified then
CPYUSRPRF2 will create a new profile from a template and assign a
password to that profile that satisfies the password rules defined
by the system values.
- CVTCERT
Convert Certificates has been enhanced to allow any user that has
the certificate store password to request a list of certificate
expiration dates from a certificate store. This was previously only
available to those users that had the password and had ALLOBJ and
SECADM special authorities. The Convert Certificates command did not
provide a very helpful messages when the user did not have the
correct password or the proper authorities. The error messages
issued are now use the system provided text.
- RTVIFSEAUT
Retrieve IFS Entry Authorities has had minor enhancements to its
internals for ILE. There should be no external effects.
- SNDSPLMAIL
Send Spool Mail has been converted to ILE and the new tool source
format. There should be no external effects.
- RSNLSTMSG
The Resend Last Message command will now skip the Program Entry
Procedure of ILE CL programs if one exists and send the message to
the caller of that program.
Fixes
- CHKIFSE
Check IFS Entry had a bug in which it detected the root IFS
directory, /, as not found. This affected a number of tools that
used CHKIFSE such as FTP2. Fortunately, not too many explicit
references to the root directory are made. This has been fixed.
It was also noted in the documentation that a CPF9898 escape message
could be sent to the caller if an unusual exception not expected by
the code occurred. Communications errors fall into this category.
- CMPLIB2
The Compare Library 2 tool would fail if the files object files in
the TOLIB library were empty. This could occur if the CAPLIB2
command was incorrectly used. The CMPLIB2 command now tolerates this
condition.
- CMPSYSVAL
Compare System Values would get an array index out of bounds if the
member on which it was operating actually contained more than one
set of data. This could show up in CMPSYSVAL or in CMPSECINF. The
system value data would have to be duplicated in one of the members
being compared for this problem to surface.
- CPYTOCSV
The Copy to CSV command would produce incorrect results if varying
length fields were present in the database file being copied. This
has been fixed.
- CVTEDTD
The Convert Edit Descriptions tool would fail in IBM i 7.5. The tool
works from the DSPEDTD spooled file output, which has been changed
in this release to add apostrophes around some of the character
fields. The tool has been modified to on IBM i 7.3, 7.4, and 7.5 to
account for the apostrophes.
- CVTIFSAUT2
The CVTIFSAUT2 command would fail on IBM i 7.5 due to a change in
the QSYLOBJA API which now reports path information in CSSID 1200
rather than the job CCSID. This command has been updated to
accomodate that change. Errors would also show up in the following
tools: RNMIFSAUT, RVKIFSAUT, RNMIFSPGP, and RVKIFSPGP which use the
CVTIFSAUT2 command internally. No changes were needed to those
tools.
- CVTOPNF
There was a small timing window in the Convert Open Files command
where it could issue a function check instead of a "job not found"
message. This has been fixed.
- CVTSBSD
The list of job queues in Convert Subsystem Description when using
the TYPE(*JOBQENT) option could be incorrect. This has been fixed.
CVTSBSD is used in other tools such as WRKSBSJOBQ.
- DLTOLDSPLF
Delete Old Spooled Files had a minor bug in which it would fail if
the underlying CVTOUTQ attempted to create the QGYSERVER jobs needed
to process output queues and those jobs hit the maximum limit of the
subsystem in which it was running. The tool was modified to use a
new version of CVTOUTQ that avoids the creation of auxiliary jobs.
- DSPIFSOWN
The QSYLOBJA API in IBM i 7.5 now reports IFS path name attributes
in CCSID 1200 instead of the job CCSID. DSPIFSOWN converts the
delimiter and path names back to the job CCSID for display.
- GENRANPWD2
The Generate Random Password 2 had a bug where *REQANY3 was not
handled properly if *DGTMIN0 and *SPCCHRMIN0 were defaulted or
specified. The fix was to force mixed case and at least one special
character if *DGTMAX0. A digit will be generated if *DGTMAXn was
either not specified or n is greater than 0.
- RSTAUTL
Restore Authorization Lists would fail if there was an unusually
large number of authorization lists to process. The temporary
database file it uses was changed to allow a larger number of
records.
- RTVIFSED
The Retrieve IFS Entry Description tool would leave a request
message in the job log if the IFS entry being examined did not
exist. The request message is now removed properly.
- RTVSMTPA
Both the RTVSMPTA and RTVSMTPA2 commands had a *ANY value that
performed no useful function. This special value has been removed
from both commands.
- SAVCHG23
The Save Change 23 command constructed an invalid SAVCHGOBJ command
if the list of BYPASS libraries contained a library name that was 10
characters. Appropriate spacing is now done.
- SCNIFS
The Scan IFS command would fail if a special value was supplied on
the OBJ keyword. This has been fixed.
- SRCARC
The Source Archive tool had a bug in the WRKSRCARC screen where it
would not display or "copy out" source if the screen was in "display
library" mode. This has been fixed.
- WRKALLSPLF
Work with All Spooled Files could resend a CPF34C4 if there were too
many spooled files on the system. This message is now handled
instead of resent.
Incompatibilities
- RTVSMTPA and RTVSMTPA2 have had the *ANY value removed. This value
did not not provide any useful function and was confusing when
prompted.
- Commands that refer to previous releases (7.5 only)
All save commands, most compile commands, and commands that use *PRV
compiler support have had their TGTRLS parameters updated for 7.5.
While technically incompatible with previous release this is
consistent with IBM i 7.5 changes. The following commands have been
affected:
---------------------------------------------------------------------------
Tool Command Description
------------ ------------ -------------------------------------------------
CHKPGMRLS CHKPGMRLS Check Program Release - CHKPGMRLS
CHKTGTRLS CHKTGTRLS Check Target Release - CHKTGTRLS
CMPOUTFILE CMPOUTFILE Compare System Outfiles - CMPOUTFILE
CRTBNDCL2 CRTBNDCL2 Create Bound CL Pgm 2 - CRTBNDCL2
CRTBNDRPG2 CRTBNDRPG2 Create Bound RPG Pgm 2 - CRTBNDRPG2
CRTSFLPGM CRTSFLPGM Create Subfile Program - CRTSFLPGM
CRTSFLPGM RPLSFLPGM Replace Subfile Program - RPLSFLPGM
CRTSFLPGM2 CRTSFLPGM2 Create Subfile Program 2 - CRTSFLPGM2
CRTTGTRLS CRTTGTRLS Create Target Release - CRTTGTRLS
RPLGENPGM RPLGENPGM Replace Generic Programs - RPLGENPGM
RPLMOD RPLMOD Replace Module - RPLMOD
RPLOBJ RPLOBJ Replace Object - RPLOBJ
RPLPGM RPLPGM Replace Program - RPLPGM
SAVACT SAVALLACT Save All Active - SAVALLACT
SAVACT SAVCHGACT Save Changed Active - SAVCHGACT
SAVJRNRCV SAVJRNRCV Save Journal Receivers - SAVJRNRCV
SAVLIBIFS SAVLIBIFS Save Library to IFS - SAVLIBIFS
SAVOBJIFS SAVOBJIFS Save Object to IFS - SAVOBJIFS
SAVONELIB SAVONELIB Save One Library - SAVONELIB
SAVOWNOBJ SAVOWNOBJ Save Owned Objects - SAVOWNOBJ
SAVRCVL SAVRCVL Save and Receive Library with FTP - SAVRCVL
SAVRCVL SBMSAVRCVL Submit Save and Receive Lib with FTP - SBMSAVRCVL
SAVSNDL SAVSNDL Save and Send Library with FTP - SAVSNDL
SAVSNDL SBMSAVSNDL Submit Save and Send Lib - SBMSAVSNDL
SAVSNDM SAVSNDM Save and Send Member with FTP- SAVSNDM
SAVSRCF SAVSRCF Save Source Files - SAVSRCF
SNDOBJMAIL SNDOBJMAIL Send Object Mail - SNDOBJMAIL
---------------------------------------------------------------------------
2021-05-15 (R72)
Refresh 72 (May 15, 2021) is for IBM i 7.2, 7.3, and 7.4. This is the
last refresh for IBM i 7.2.
No further refreshes will be made for IBM i 7.2. However, fixes to 7.2
tools will continue to be supplied on an "as needed" basis until April
30, 2024.
No further refreshes or fixes will be made for IBM i 7.1.
New Tools
- CPUMON
The CPU Monitor tool monitors for jobs that consume CPU resources
above a specified CPU percentage. When a job is found running above
the CPU limit, a message alert is sent to the specified message
queue describing the job which is using too much processing time. If
several jobs are found to be over the limit, multiple messages will
be sent to the message queue - one for each detected job.
- RTVJOBSPLC
The Retrieve Job Spool Count tool will efficiently return the number
of spooled files created in a job. This count includes files in FIN
state and can be used to compare against the system value QMAXSPLF
to see if a job is near the system specified limit.
Enhancements
- CHKJOBMSGW
A new keyword, JOBQ, has been added to specify where to submit the
CHKJOBMSGW job. It defaults to QSYS/QSYSNOMAX, which was the queue
used prior to this enhancement.
- CRTSTDSRCF
A new keyword, BYPEXIST, was added to Create Standard Source Files.
The default is *NO and that preserves the previous function. *YES
will allow the files that do not exist in the specified library to
be created.
- DSPMSGQA
The Display Message Queue Attributes tool was enhanced so that the
printed report now includes all the attributes of the displayed
report.
- DUPALLSPLF
Time fields have been added to the FROMDATE and TODATE parameters
for DUPALLSPLF. This allows for a much finer-grained duplication.
- ENDSBSJOB
*CURRENT was added as a parameter for the USER keyword.
- MNTALLJRN
The Maintain All Journals command has a new parameter that allows
the deletion of journal receivers that are in %ELG state. This
happens if the receiver has been saved, but no save date is present
in the object description. This happens for receivers that have been
saved with UPDHST(*NO). Receivers in QSYS are usually saved this
way.
Fixes
- Install
The CRTFNDCMD that indexes commands at the very end of the install
process could fail in very rare circumstances when indexing the
commands in all libraries. Install has been modified to index only
QSYS and TAATOOLS. If other libraries are desired you can rerun
CRTFNDCMD after the the install has completed with the libraries of
your choice.
- CAPSECINF
The RFMSECINF command of the Capture Security Information tool is
automatically invoked if changes in the security information file
formats are detected. A bug was fixed that would fail to reformat
the user profile files correctly.
- CHGLIBOWN
The CHGLIBOWN tools would receive a MCH1210 exception when dealing
with extremely large libraries. This has been fixed.
- CHKBLKFLD
The Check Blank Field command would attempt to use an incorrect
message file when sending a message about an empty member. This has
been fixed.
- CHKIFSE
The Check IFS Entry command would fail if the path specified ended
with a '\'. This has been fixed.
There was also an issue where \ was not being converted to / if the
path was "triple-quoted". This has been fixed as well.
- CPYFRMCSV
The Copy from Comma Delimited File command would fail with a CPF3303
error if it was run in a server job, such as from an ACS SQL
session. This was due to the the fact that spooled files in server
jobs are created in a separate QPRTJOB job instead of the server
job. The QPDDSSRC spooled file that was causing the issue is now
owned by the server job and properly deleted.
- CPYFRMSTM2
The Copy from Stream File 2 command would fail if copying from a
stream file with an extremely long name. This has been fixed.
- CRTDBFJRN
This command would fail when converting from a table created with
DDL that contains CURRENT_TIME or CURRENT_TIMESTAMP defaults. This
has been fixed. The command would also fail if run in a server job
since it could not find a temporary spooled file. That file is now
owned by the server job instead of the QPRTJOB for the current user.
- CVTIFS
The pattern matching algorithm used in CVTIFS would not properly
match some complex patterns i.e. those with multiple asterisks. The
asterisk now matches the shortest string between constant strings in
the pattern even if that string is a null string.
- CVTIFSAUT2
In extremely rare circumstances the Convert IFS Authorities 2
command could get an MCH0601 as it was processing the user space
returned by an API. This has been fixed.
- CVTJOB
The Convert Job command would fail if there were more than enough
jobs to fill a single user space with the QUSLJOB API (about 280,000
jobs). The tool has been updated to use the QUSLJOB continuation
handle support. There is now no practical limit to the number of
jobs it can convert.
- CVTOBJAUT
The CVTOBJAUT command does not work with QTEMP, but using it on
QTEMP failed to give an adequate report. This has been fixed.
- CVTSBSD
The CVTSBSD command would produce some error messages when examining
the job queues of subsystem descriptions. This did not affect the
results, but could be confusing. Those error messages have been
removed.
- DLTUSRPRF3
If DLTUSRPRF3 was used to transfer ownership of objects when
deleting a user profile those objects were deleted instead of being
transferred. We issued a HIPER Alert for this and distributed the
fix early. That fix is included in this refresh. Note that the patch
had 'Delete User Prof 3 - TAA-0001' as the prompt heading for the
command. This refresh restores the previous prompt heading of
'Delete User Profile 3 - TAA'.
- DSPALLJLG
Display All Joblogs would fail with a CPF34C4 (list too large for
user space) if there were a fairly large number spooled files on the
system. The code has been changed to ignore this error and process
whatever spooled files are returned by the QUSLSPL API.
- DSPALLSPLF
Display All Spooled Files would fail with a CPF34C4 (list too large
for user space) if there were a fairly large number spooled files on
the system. The code has been changed to ignore this error and
process whatever spooled files are returned by the QUSLSPL API.
- ENDSBS2
The ENDSBS2 command would fail if the subsystem referred to in the
command was already ending controlled. The command now recognizes
this situation and proceeds.
- NBRCTR
The ADDNBRCTR command of the NBRCTR tool would receive a size
exception when the amount to add keyword was 99999. This has been
fixed.
- PRTALLOUTQ
The Print All Output Queues would fail if an output queue exceeded
13,000 spooled files. This limit has been increased to 1,000,000
spooled files.
- PRTLIBANL
The PRTLIBANL command would fail doing a CPYF if there was a
mismatch between the outfiles used by it and the DSPUSRPRF command.
This could happen if the tools and the underlying IBM i were out of
sync. A *MAP option was added to the CPYF command to prevent this.
- RTVOBJJRNA
The Retrieve Object Journal Attributes would send a TAA9896 escape
message indicating that only physical files could be journaled when
presented with a logical file that had a journaled access path. This
now reports correctly for logical files.
- RTVOBJLST
The RTVOBJLST tool would receive a MCH1210 when dealing with
extremely large libraries. This has been fixed.
- RTVPFSRC
The Retrieve PF Source command will not retrieve CURRENT_TIME or
CURRENT_TIMESTAMP defaults from DDL into DDS since these are not
allowed in DDS. It will no longer attempt to generate ALIAS keywords
if the name that contain a #, $, or @. These cause DDS errors. The
command also now works when the current user and job user are
different, such as in a server job.
- RTVSTGPOOL
The Retrieve Storage Pool command is used by the Display Subsystem
command. In systems with very large main stores this command would
fail of the storage size in KB exceeded 9 digits. If this happens
now, the value returned is 999,999,999.
- SNDIFSMAIL
The Send IFS Mail command is can be used stand-alone or internally.
It constructs a temporary working folder with a unique name in
/QDLS/TAAFLR. If that folder name was longer than 4 characters the
resulting document name would be truncated and the tool would fail.
This would happen only after about 1.6 million uses of the tool.
This has been fixed.
- SNDSPLPDF
The Send Spool File as PDF command would fail if the number counter
used by the tool to create unique working folders in the IFS did not
exist. This has been fixed so that the counter is created. The
command might also fail if the working folders existed. The command
now skips over existing working folders.
- SNDTXTMAIL
The Send Text Mail command constructs and issues a LOGMAILENT
command. This would fail if the MAILADRP address name contains
non-system-name characters such as a hyphen. The address names are
now quoted if they contain non-system-name characters.
- SPLARC
The STRSPLARC command of the Spool Archive tool did not take the
spooled file creation date into account when looking for spooled
files to archive. This led to rare situations where the wrong file
was archived if there was a job number wrap condition. This has been
fixed by checking the spooled file creation date as well.
- SRCARC
The SRCARC tool had several commands that had limiting dates of
2020-12-31. These have all been changed to 2099-12-31.
- STRJRNLIB2
This would stop processing objects in a library if it ran into a
logical file that had its access path already being journaled. It
now skips those files and continues as it does with other objects
that are already journaled.
- WRKASP
The Work with ASPs command would duplicate the previous ASP name on
the display if an ASP was found but was in offline state. This now
shows as *OFFLINE.
- WRKSPLF2
The Work with Spooled Files 2 command would fail if the combined
queues being examined exceeded 9999 spooled files. The display is
now capped at 9998 spooled files.
Incompatibilities
- There are no known incompatibilities in this refresh.
2020-04-15 (R71)
Refresh 71 (April 15, 2020) is for IBM i 7.2, 7.3, and 7.4.
No further refreshes will be made for IBM i 7.1. However, fixes to 7.1
tools will continue to be supplied on an "as needed" basis until April
30, 2021.
New Tools
- CVTACCPTH
The Convert Access Path command produces an outfile of physical and
logical files which have a 4 GB max access path limit. The outfile
can be checked for files which are approaching their 4 GB limit. Use
of this tool could prevent applications to fail if the 4 GB limit is
surpassed.
- CVTCERT
The Convert Certificates command produces an outfile of information
from server or certificate authority certificates on your system.
Most notably, certificate expiration dates are output, giving
administrators an easy way of checking which certificates need to be
renewed before they expire.
Enhancements
- Install
The installation procedure now has the capability of adding new keys
to application values found in TAASECURE. This will allow future
tools to add new capabilities using application values without
adding entirely new APPVAL structures in that library.
- CHGOWNOBJ
The Change Owned Objects command has been enhanced to include two
new parameters: ACTION and ESCAPE. ACTION(*CHECK) allow you to see
what would be changed if ACTION(*CHANGE) is used. *CHANGE is the
default. ESCAPE(*YES) will prevent the use of any profile beginning
with Q. This is to prevent the wholesale assignment of ownership
from system-supplied profile. *YES is the default. This introduces
an incompatibility.
- CVTOBJLCK
The Convert Object Lock command converts object locks to the OBJLCKP
data base file with one record per lock. This allows you to
determine who has the lock within a program. A field was added to
show the current user profile holding the lock.
- CVTOUTQ
Convert Output Queue uses a system API to find the contents of an
output queue. Normally this system API will submit auxiliary jobs to
perform an ansynchronous listing of the queue contents. This makes
the tool more responsive. In some cases this submission of auxiliary
jobs is not desirable; for example, when the subsystem in which this
tool runs is near its maximum number of jobs. A new AUXJOB keyword
has been added to the command to suppress these jobs and perform the
listing synchronously.
- MTNJRN
A new SEQOPT keyword was added to Maintain Journal so that the
sequence numbers in the journal receivers can be reset during MTNJRN
processing. The default is to continue the sequence numbers as it
had been doing.
- RTVMTHDAT / RTVSOMDAT
These two commands allow retrieval of dates based on specified
criteria. RTVMTHDAT and RTVSOMDAT commands have been enhanced to
support the *NEXT value for MONTH and YEAR parameters.
- SCNALLSRC2
Scan All Source 2 will scan for up to 20 arguments in source files
in one or more libraries. SCNALLSRC2 was enhanced with a FILE
parameter, allowing the search to be narrowed to named source files,
such as QCLSRC, QRPGLE, etc.
- SECOFR2
The SECOFR2 menu entry for CPYUSRPRF2 now allows the prompt for this
command to be tailored so that the new PWDEXP and CHGOWN parameters
can be masked. See the documentation for SECOFR2 for more
information.
- WRKVTP
Work with Virtual Tape allows you to review and control the virtual
tape devices created by CRTVTP. WRKVTP usage of available resources
was improved by refreshing the available resource list before
executing F8 = Avail Resources. Also, F9 command text was improved
to indicate that either a 'Not detected' resource or a New resource
will be returned.
Fixes
- ADDJOBSCD2
The Add Job Scheduler 2 command is used to add multiple job
scheduler entries from a database file. A quoted entry would cause
problems for subsequent entries found in the file. This has been
fixed.
- ALCTMPMBR
The Allocated Temporary Member tool is used internally by several
other tools. In extremely rare circumstances this tool would fail
and the tool using it would report the failure. It would have to be
the first tool executed after midnight on a given day. This has been
fixed. This initially showed up occuring in CVTQHST2.
- CPYGENSRC
The Copy Generic Source command options for the source file lists
(SRC1, SRC2, and *SRC3) were not working. The source lists are now
read and processed correctly.
- CVTLIBCNT
Convert Library Count creates an outfile with one record summarizing
the objects in each library requested. CVTLIBCNT was fixed to bypass
libraries that are too large to process in the user space. When
CVTLIBCNT encounters such a library, it bypasses that library and
then goes on to process the remaining libraries requested. An escape
message is sent at the end in this situation.
- CVTTAPSAVD
This Convert Tape Save Description command would fail if the device
was a tape library or autoloader, a specific library/label was
named, and VOL(*MOUNTED) was specified. This has been fixed.
- ENDJOBWOL
End Job With Object Locks has been fixed to run in batch as well as
interactive environments.
- SNDINTMSG
The Send Interactive Jobs a Message tool was failing if the caller
did not have explicit authority to read the application value used
to control its use. This application value should be able to be read
by the tool for any user authorized to the tool. The authority issue
with a helper program has been fixed.
- RMVSUPGRP
Remove Supplemental Group allows the removing of a supplemental
group profile from one or more user profiles. This command was fixed
to issue better completion messages.
- RTVSYSPTN
Retrieve System Partition returns information about the partitions
on a system and the current partition. RTVSYSPTN was returning the
opposite Capacity Capped value than it should. The tool was changed
to return the correct value.
- SAVRSTJOBQ
The Save and Restore Job Queue tool supports two commands which
support the save and restore of a job queue. CVTJOBQ2 creates an
outfile of information about the jobs on a job queue, then SBMJOBQ2
command is used to read the outfile and perform a SBMJOB for each
job found in the outfile. The outfile name was not being set
correctly when SBMJOBQ2(*OUTFILE) was specified. This has been
corrected.
- SCNSPLF
Scan Spool File scans a spool file for a string and returns a count
of how many strings were found. A fix was added so scan arguments
over 10 characters would be found correctly.
- SNDTCPOUTQ
The Send TCP Output Queue tool would fail in very rare circumstances
due to a time out waiting for a port to become available in the
SNDTCPSPLF tool. Retry logic has been added to minimize this
possibility even further and, if the port does not become available,
an informational message is logged rather than the tool failing.
Incompatibilities
- CHGOWNOBJ
The new ESCAPE keyword on CHGOWNOBJ defaults to *YES. Any programs
using CHGOWNOBJ with a from user or to user beginning with a Q will
fail with a TAA9891 exception. You can use ESCAPE(*NO) to suppress
this exception.
- CVTOBJLCK
The outfile for CVTOBJLCK has been modified to add a new field
identifying the current user to the end of the record format.
Outfiles from previous versions of the tool will need to be deleted.
The tool will re-create these on first use.
2019-08-15 (R70)
Refresh 70 (August 15, 2019) is for IBM i 7.2, 7.3, and 7.4.
No further refreshes will be made for IBM i 7.1. However, fixes to 7.1
tools will continue to be supplied on an "as needed" basis until April
30, 2021.
New Tools
- CMPENVVAR
The new Compare Environment Variables command allows a comparison of
environment variables between two systems or two versions converted
from the same system. A listing is printed noting the differences
between the two ENVVAR files being compared.
- CVTENVVAR
The new Convert Environment Variables command converts job and
system environment variables to an outfile. The outfile can be used
to verify current environment variable settings, or to compare
ENVVAR settings overtime to ensure they remain consistent on the
system.
Enhancements
- Support for IBM i 7.4
A new version of the tools has been created to install and run on
IBM i 7.4. If you upgrade your system to IBM i 7.4 you will have 60
days in which to upgrade the tools to match the operating system.
The 7.3 and prior versions of the tools are not supported on IBM i
7.4 so you are encouraged to upgrade promptly.
- Support for multiple licenses
The tools can now support multiple licenses on a single system. This
makes it much easier to manage cases where the system image must be
switched or replicated to a system with a different serial number.
This would include cases for capacity backup (CBU), disaster
recovery (DR), high availability (HA), or live partition mobility
(LPM).
Supplemental licenses can be installed in addition to the base
license for a system. The base license is created either during
install or with CHGTAAKEY. Its serial number must match the system
at that time. Supplemental licenses are installed on that same
system and can reference other serial numbers. If a license check
fails for the base license, the supplemental licenses are checked.
The base license resides in the TAATOOL/TAALICENSE data area. There
can be up to 9 supplemental licenses in TAATOOL named TAALIC_001
through TAALIC_009. You create a supplemental license using the
CHGTAAKEY command as follows:
CHGTAAKEY KEY() LICNBR(1)
This creates a supplemental license in TAALIC_001.
When the additional system is used, the base license and
supplemental licenses are available since they've been replicated or
switched. The base license check will fail, but the supplemental
license check will succeed. This will be entirely transparent to
you.
- Support for handling * and ? in IFS names
The Root and QOpenSys file systems in IFS can have files and
directories that have the * and ? characters in the names. Various
IFS command would come across these while scanning the directory
structure and treat these as pattern names. Several commands have
been updated to handle these names properly - most notably DLTIFS.
The commands now also allow for quoting arguments in the same manner
as WRKLNK. Thus, if you don't want a pattern match you have to quote
the designated string twice on the command line. For example,
suppose you have the following files in your home directory:
aaa.txt
abc.txt
abc*.txt
abc?.txt
abc'.txt
Let's assume the current directory is your home directory.
The following command lists four files.
WRKLNK 'abc*.txt'
But this command only lists one file.
WRKLNK '''abc*.txt'''
Thus, the following command would delete the four files that begin
with abc.
DLTIFS OBJ('.') OBJNAM('abc*.txt')
However, as expected, this command would delete only abc*.txt.
DLTIFS OBJ('.') OBJNAM('''abc*.txt''')
- CHKIFSDMG
Check IFS Damage works by saving the IFS objects to a temporary save
file. It now provides diagnostic information in the job log that
shows the save file size calculation in case of a CRTSAVF failure.
- CPYUSRPRF2
Copy User Profile 2 is an option on the SECOFR2 menu. It allows an
"assistant security officer" the ability to establish a user profile
by copying an existing one and initializing its password with
INZPWD. CPYUSRPRF2 is now disabled if *ALLCRTCHG is specified in the
QPWDRULES system value since the intent is to give the user a
relatively easy password that will be immediately changed.
- CVTQRYSTMT
Convert Query Statement was enhanced to allow it to be used in
batch.
- CVTSBSD
The Convert Subsystem Description tool was enhanced to include the
last used date for the job queue in the SBSJBQENT outfile that is
produced.
- CVTSYSVAL
Convert System Values has been enhanced to fully capture all the
system values. Prior to this refresh some long system values were
not being fully captured.
- DSAOLDPRF
We added a parameter to the DSAOLDPRF command that allows you to
select a method for disabling old profiles. The *CHGUSRPF default
method will disable any profile that meets the aging criteria
including QSECOFR. The *DSAUSRPRF method will use a DSAUSRPRF
command and can be more selective. It will never disable QSECOFR and
other profiles can be protected as well. See the documentation for
DSAUSRPRF for details.
- DSPSBMJOB
Display Submitted Jobs received several enhancements.
1. Job numbers can roll over. Jobs are now sorted by their entry
date and time, not by job number so job number rollover no
longer prevents toggling between ascending and descending order.
2. Option 8 now shows an appropriate message if the job no longer
exists in the system.
3. Displaying with no jobs now allows F5=Refresh and
F6=Ascending/Descending.
4. A misbehaving SPLFPGM will no longer terminate the command, but
will halt processing of the list.
5. DSPSBMJOB now shows batch immediate jobs as submitted jobs.
These jobs are usually started by the system to carry out
asynchronous tasks for long running APIs. WRKSBMJOB does show
these.
- DSPSUMJOBQ
The Display Summary of Job Queue command was enhanced by adding a
sequence parameter to sort the outfile by ascending or descending
order.
- EXCCMD
The Execute Commands command can print a list of commands that were
executed from a source file. This listing would truncate some lines
if they were too long. The tool now prints a longer line along with
its change date.
- GENRANPWD2
The Generate Random Password 2 tool has been enhanced so that it now
respects all the settings for QPWDRULES that could apply to
generation without knowing the password history.
The following QPWDRULES are now supported:
*PWDSYSVAL
*MAXLENnnn *MINLENnnn
*REQANY3 *MIXCASEn
*CHRLMTAJC *CHRLMTREP
*LTRMIN *DGTMIN *SPCCHRMIN
*LTRMAX *DGTMAX *SPCCHRMAX
*LTRLMTAJC *DGTLMTAJC *SPCCHRLMTAJC
*LTRLMTFST *DGTLMTFST *SPCCHRLMTFST
*LTRLMTLST *DGTLMTLST *SPCCLHRMTLST
If QPWDRULES is set to *PWDSYSVAL then the following
system password rules are supported:
QPWDMAXLEN - like *MAXLENnnn
QPWDMINLEN - like *MINLENnnn
QPWDLMTREP - like *CHRLMTAJC or *CHRLMTREP
QPWDRQDDGT - like *DGTMINn (n is 0 or 1)
QPWDLMTAJC - like *DGTLMTAJC
QPWDLMTCHR - no corresponding rule in QPWDRULES
This is only used if the password level is 0 or 1
- PRTJRNRCV
The Print Journal Receivers command has been enhanced by adding two
fields to it's output - the first sequence number and volume ID.
This allows you to identify which media volume (usually tape) on
which the journal receiver is stored.
- QRYUSE
The Convert Query Statement command of the QRYUSE tool was enhanced
to allow the tool to run in all environments, including batch.
- RPLSYSVAL
The Replace System Value tool has been enhanced to be able to set
the QSSLCSL value if QSSLCSLCTL is set to *USRDFN. QSSLCSL was being
skipped and had to be manually set.
Also the exception report produced by RPLSYSVAL now has all of the
message text associated with any errors that might be encountered
when doing the CHGSYSVAL.
- RTVDBR
The Retrieve Database Relations was enhanced to show the additional
view of dependencies of a logical file.
Fixes
- APYUSRCHG
Apply User Journal Changes overrides a printer file to change the
name of the report to the name of the file whose changes were being
applied. This was failing if changes were being applied to *ALL
files. The override in this case now assigns APYUSRCHG to the name
of the report.
- CHGOBJAUT
The Change Object Authorization would occasionally fail when used by
the CVTWRKACT tool. This was due to an undocumented lock on the
output file being held by a system thread in CRTDUPOBJ. The
workaround is to wait on a lock for the object held by that thread
and proceed when that lock is acquired.
- CPYSPLFIFS
The Copy Spooled File to IFS would fail when creating a PDF when the
overflow line of the spooled file was less than 60. This has been
corrected.
- CVTJRNA
The Convert Journal Attributes tool is used by several other tools.
In very rare circumstances the tool would fail if the files being
journaled were deleted while it was running. Monitors have been
added to check for this condition.
- CVTJOBACG3
The tool was not behaving well for ENDJOB *CNTRLD if accounting
entries were being added on a frequent basis. The check for the
*CTRLD end is now being made more frequently.
- CVTLIBLCK
The Convert Library Locks tool would fail if an override existed for
the file TAATOBJDP - the model file for the output from the command.
This has been fixed.
- CVTMSGQ
The Convert Message Queue tool could fail in rare circumstances with
an index out of range due to extremely long messages in the message
queue.
- DSPMSGQINQ
The Display Message Queue Inquiries command would sometimes miss an
inquiry message if those messages were present next to each other
without replies in the message queue. This has been fixed.
- DSPSBMJOB
In some was possible for Display Submitted Jobs to get a pointer
error if there are a large number of job entries on the system. This
has been fixed.
- ENDSBSJOB
The End Subsystem Jobs command was fixed to continue processing when
a job not found condition was encountered. This avoids command
exceptions due to system timing conflicts when jobs end before the
command completes.
- FNDCMD
The Find Command tool would give a date conversion error when the
command index file would exceed 183 days old. A parameter size was
fixed to correct this problem.
- INZPWD
The INZPWD and INZPWD2 commands will only use GENRANPWD2 if
QPWDRULES system value specifies *ALLCRTCHG. If it is not specified
then the passwords generated for users will be follow simpler rules
that might not conform to the password rules. This is desirable for
help desk use.
- MTNJRN
The Maintain Journal command would not delete journal receivers in
SAVED state if SAVINQMSG(*BYPASS) was specified and if the receiver
had no object saved date. This could happen if the receivers had
only been saved with GO SAVE 21 or SAVSYS. The receivers in SAVED
state will now be deleted if they meet the attach or detach date
qualfications for removal regardless of the save date.
- MONMSGQ
The job submitted by SBMMONMSGQ would occasionally report on
messages that had blank message ids. These have been removed.
- RTVAUDMDLF
The IM type was missing as a valid type for the retrieve. This has
been corrected.
- RTVSYSSTS
The Retrieve System Status command changed to correctly retrieve the
LPAR current available processor for the CURPRCCAP parameter.
- VALDBF
The Validate Database File command has been changed to bypass null
capable files, or files whose record length exceeds 4000. This
improves VALMNYDBF, which would throw errors when these conditions
were encountered. Now the files are bypassed, and a message is
issued.
Incompatibilities
- Commands that refer to previous releases (7.4 only)
All save commands, most compile commands, and commands that use *PRV
compiler support have had their TGTRLS parameters updated for 7.4.
While technically incompatible with previous release this is
consistent with 7.4 system changes. The following commands have been
affected: CHKTGTRLS, CMPOUTFILE, CRTBNDCL2, CRTBNDRPG2, CRTSFLPGM,
CRTSFLPGM2, CRTTGTRLS, RPLGENPGM, RPLOBJ, RPLMOD, RPLPGM, RPLSFLPGM,
SAVALLACT, SAVCHGACT, SAVJRNACT, SAVLIBIFS, SAVOBJIFS, SAVEONELIB,
SAVOWNOBJ, SAVRCVL, SAVSNDL, SAVSNDM, SAVSRCF, SBMSAVRCVL,
SBMSAVSNDL, SNDOBJMAIL.
2018-10-15 (R69)
Refresh 69 (October 15, 2018) is for IBM i 7.2 and 7.3.
No further refreshes will be made for IBM i 7.1. However, fixes to 7.1
tools will continue to be supplied on an "as needed" basis until April
30, 2021.
New Tools
- ADDDSTLE2
Add Distribution List Entry 2 is a new tool to assist with adding
users to the same distribution lists to which another user belongs.
If the user is already on one of the identified lists, no action is
taken.
- FNDMSGID
Find Message ID is a new tool which will find the message file(s)
that hold a message ID. This is very useful when handling jobs which
list a message id with and unknown message file. The product issuing
the message can often be identified this way.
- SCNALLDSTL
Scan All Distribution Lists is a new tool to scan all distribution
lists for a particular User ID. An output file is created listing
all the dist lists in which the User ID was found.
Enhancements
- CVTIFSAUT
Performance of CVTIFSAUT has been improved by streamlining the
connection between it and the CVTIFSEAUT tool.
Fixes
- CVTJOB
The CVTJOB command would occasionally get decimal data errors when
dealing with a very large number of jobs. The module using the
QUSLJOB API has been rewritten to avoid this problem.
- CVTLIBOBJA
The Convert Library Object Authorities command would fail when
LIB(*ALL) was requested. The tool has been fixed to handle the *ALL
parameter.
- CVTMSGQ
The Convert Message Queue tool could fail in rare circumstances with
an index out of range. This has been fixed.
- DSPAUDLOG2
The Display Audit Log 2 display was not updating the minutes field
of the TIME column properly. This has been fixed.
- DSPJOBSCDC
The Display Job Schedule Calendar tool was showing jobs scheduled
starting tomorrow. The tool was changed changed to display jobs that
are scheduled to run from the system job scheduler for the next 7
days, starting today.
- DSPJOBSCDE
The Display Job Schedule Entry tool was always displaying jobs in
scheduled order, even when SEQ(*JOB) was requested. SEQ(*JOB) now
displays in job name order.
- DSPSBMJOB
The Display Submitted Jobs tool was not displaying the jobs that
were submitted by the current user on behalf of another user. For
example, if SBMJOB CMD(...) USER(OTHER) was used then that job was
not appearing on the DSPSBMJOB display. In addition, jobs belonging
to the current user, but not submitted by the current user were
being displayed. Both of these problems have been fixed. DSPSBMJOB
now functions as documented and behaves similarly to WRKSBMJOB.
- DSPSBSJOBQ / WRKSBSJOBQ
The DSPSBSJOBQ / WRKSBSJOBQ display output was not refreshing
correctly. The job number in the header was not updating, and once a
job queue had all completed jobs, the queue did not list *Nojobs*.
Both these problems have been corrected.
- EDTDTAARA
The Edit Data Area tool will acquire an exclusive lock on the data
area being edited. The tool presents a warning if you attempted to
edit a character data area containing data with code points below
x'40'. Canceling this warning failed to release this lock. This has
been fixed.
- GENRANPWD2
The Generate Random Password 2 tool was throwing an error when
PWDLVL was set to 0 or 1. GENRANPWD2 was generating passwords which
included lowercase characters, which is not supported with PWDLVL 0
or 1, causing INZPWD2 and INZPWD to fail when requested to generate
a random password. This has now been corrected in the GENRANPWD2
tool.
- PRTREVERSE
The Print Reverse tool was cutting off the last line of the last
page when reverse printing a spool file. This has been corrected.
- RTVIFSEAUT
The Retrieve IFS Entry Authority tool uses system APIs that cannot
be run if the job is multithreaded. Some tools, such as SNDSPLPDF,
use APIs that now spin off threads in the current job. RTVIFSEAUT
will now wait for those threads to finish instead of failing with an
exception when used in those tools.
- RTVSBSBCH
The Retrieve Subsystem Batch Status tool would fail if the subsystem
description for the named active subsystem could not be found in the
library list. A fix was made so that the library of the active
subsystems is correctly determined. In addition, the RTVSBSBCH
command documentation indicated that *ALL was valid. It is valid on
PRTSBSBCH, but not on RTVSBSBCH. The documentation has been
corrected.
- SNDSPLPDF
The Send Spool as a PDF tool documentation was updated to indicate
that both PASE and Transform Services are required to run this tool.
- SPLSTO
The Print Spool Store (PRTSPLSTO) command in the Spool Store tool
(re)prints a stored spooled file. If that spooled file was created
with an output queue specified as *DEV, *JOB, or *SAME then the
output queue must be determined at run time. This is now done
properly.
- TAATOOL/TAAARCAC2 data area locked during install of the tools
After an IBM i release upgrade the data area TAAARCAC2 in TAATOOL
could be locked by the TAAINQMSG2 job. The install process for the
tools now ends this job so that the TAATOOL library can be cleared
and refreshed.
Incompatibilities
There are no known incompatibilities in this refresh.
2018-04-15 (R68)
Refresh 68 (April 15, 2018) is the last refresh for IBM i 7.1. Fixes
to 7.1 tools will continue to be made on an "as needed" basis until
April 15, 2020.
New Tools
- GENRANPWD2
The Generate Random Password 2 command generates a random password
according to the system password rules which are set. This tool is
available only on IBM i 7.2 and later.
- RTVJOBOUTQ
Retrieves the output queue of a job resolving any special values.
Enhancements
- CVTJOB
Convert Job was enhanced to add two new character timestamp fields
for job start and end times. These are blank if they don't apply.
This affects the model outfile. Outfiles from previous versions of
the tool will need to be deleted. The tool will re-create these on
first use.
- DSPDTAQ, DSPDTAQD, and RTVDTAQ
These tools have been enhanced to support data queues up to
99,999,999 entries in length.
- INZPWD
The Initialize Password command(s) set a user profile to a new
password. A new INZPWD3 password has been added in IBM i 7.2 and
later. The password generated using INZPWD3 will comply with the
system values.
- SCNDBF
A new parameter, IGNMAPERR, was added to the SCNDBF command to
ignore data mapping errors when scanning. The default is *NO.
Fixes
- CAPSYSINF
The Capture System Information command was fixed to correctly skip
/QSYS.LIB entries when capturing information on all IFS entries.
- CLRMSGQ2
Clear Message Queue 2 was not correctly marking message queues that
contained messages that could not be deleted. This condition was
rare. Those queues are now marked appropriately.
- CMPSYSINFI
The Compare System Information for IFS command was fixed so that the
temporary files that are used in the will not require extension by
the system operator.
- CPYGENSRC
When doing a CPYGENSRC FROMFILE(LIB1/*ALL) TOFILE(LIB2/*FROMFILE)
the members that were selected for copy all ended up in the first
file selected instead of the matching file name in the second
library. This has been corrected.
- CVTJRNA
There were cases where CVTJRNA could issue an array bounds check if
there were a large number of files being journaled to this journal.
This has been fixed.
- CVTLIBDBF
Under rare circumstances on 7.3 the CVTLIBDBF tool would fail on a
CPYF command insisting that the FMTOPT(MAP DROP) had to be coded. We
added that keyword which fixes the issue. CVTLIBDBF is used by
RGZLIB and the problem initially appeared in that context.
- CVTWRKACT
Convert Work Active would always include jobs with a blank status
even if a desired set of active job status values was specified.
Jobs with a blank active status are in a short-lived transition
state and should not have been included. They will now only be
included if STATUS(*ALL) is specified.
- DSPDTAQ
OUTPUT(*PRINT) would end with an MCH1210 when 9999 data queue
entries had been printed. It now supports all the entries that can
be retrieved with one call to the system API.
- FNDSRCTXT
The Find Source Text command would occasionally miss one of the
members whose descriptive text matched the pattern given on the
command. This has been fixed.
- MSGCTL
The MSGCTL tool was found to incorrectly log and forward messages
that matched a generic message ID found in the MSGCTLP file. This
has been fixed.
- RTVJOBSTS
The command can return a list of jobs if a specific job is not
specified. The command and documentation were updated to ensure this
was properly filtered by the CURUSER keyword.
- SBMJOBSCDE
The Submit Job Scheduling Entry submits a job based on the
parameters in a job scheduling entry. One of these is the job
description which was not found in some circumstances. This has been
fixed.
- SCNIFS
The Scan IFS command was fixed to prevent looping on very large
files.
- WRKIPDEV
The Work with IP Devices tool can be used to show remote printer
queues as well as printer devices. This was showing SNA defined
remote queues and showing the remote queue name instead of the host
IP name of remote queues. It now shows only IP defined remote queues
and gives the first 15 characters of the host name in the IP address
field if the queue is defined with that instead of an IP address.
- WRKSBSD2
The Work Subsystem Description 2 command was incorrectly adding
quotes to the compare value *ANY on the Routing Entries screen. This
has been fixed.
- WRKSYSINF
The Work with System Information command now correctly removes the
IFS entry information when removing a capture. This also fixes some
interaction anomalies that may have occurred when removing a
capture.
Incompatibilities
CVTJOB
- The outfile for CVTJOB has been modified to add two new fields to
the end of the record format. See enhancements above. Outfiles from
previous versions of the tool will need to be deleted. The tool will
re-create these on first use.
2017-10-15 (R67)
New Tools
- DSPFCNUSG2
Display Function Usage 2 is a new tool which generates a Function
Usage Report. This report displays the list of function identifiers,
along with associated usage information for each entry.
- ENDSBS3
The End Subsystem 3 command will quiesce a system, but not take the
system completely to restricted state. All subsystems will be ended,
except QCMN, QHTTPSVR, QSERVER, QSPL, QSYSWRK, QUSRWRK, TAAUPSMON,
the controlling subsystem, and those specified in the OMIT
parameter.
- WRKACTGRP
Work With Activation Groups is a new tool which provides a work
display for all activation groups owned by the current job. An
option to display attributes is available, as well as a reclaim
option to free system resources.
Enhancements
- CMPLIB2
The Compare Library 2 command was enhanced by adding a CMPMBR
keyword that can be used to suppress the member compare. This allows
a shorter report to be produced.
- CPYUSRPRF2
The Copy User Profile 2 command was enhanced to include two new
parameters that assist in using the command in batch mode. The
PWDEXP parameter was added to allow a *RANDOM password be active
rather than the default of expired. The CHGOWN keyword was added to
allow the new profile to be owned by its creator rather than the
default of QSECOFR.
- RUNIO
The Run I/O tool was enhanced to allow the output file to be located
on an iASP and to provide more flexibility with the test record
length. A limit was added to control the amount of disk storage
consumed by the output file.
- SAVSYSBCH
The Save System in Batch command has been updated to include a new
CHKSAVDEV parameter that allows you to skip the tape device check.
This may be necessary if you are using BRMS.
Fixes
- CHGOBJAUT
The Change Object Authority command was receiving a "spooled file
not found error" for its report when running inside a server job. It
now correctly releases the spooled file if it is owned by a QPRTJOB.
- CMPCMDLST
Compare Command List compares 'select' and 'omit' lists to ensure
uniqueness from each other. Fix added to handle *ALLUSR value passed
from DLTUNULIB command.
- CRTVTP
The Display Virtual Tape command of the Create Virtual Tape tool
would get an exception if there were no image catalogs on the
system. This was a rare, but possible, occurence. This exception is
now monitored.
- CVTIFS
The Convert IFS command would sometimes fail when given a symbolic
link at which to start. This has been fixed.
- CVTJRNA
The Convert Journal Attributes command was ignoring the MBROPT(*ADD)
option for the JRNRCVP file. This has been fixed.
- CVTSYSVAL
The Convert System Values command was not treating QALWUSRDMN values
as a special "list type" value. It is now treated as such and
converted appropriately.
- DLTOLDQRPL
Delete old QRPLOBJ objects would receive an MCH1210 (size error)
when removing too many objects from QRPLOBJ library. The field size
was increased to prevent this.
- DLTOLDSPLF
Delete Old Spooled Files is designed to allow clean up of old spool
files by selection criteria. Found and fixed two extremely rare
problems. Fixed to delete spool files of jobs with duplicate names
due to job number wrapping. Fixed to prevent a MCH0603 when large
numbers of excluded jobs were specified several times in a job.
- DSPDTAQ
Queue entries that were longer than 9000 bytes could cause a
subscript range error when OUTPUT(*PRINT) was specified. The limit
was increased to 10,000 bytes and 1,000,000 entries. The
subscripting error has been fixed.
- DSPIFS
There was a bug in which the OWNER keyword used for selecting
entries might be ignored under some circumstances. This has been
fixed.
- DSPWHRUSE
Display Where Used shows which programs use, display, or call which
files. Certain object types were being skipped. This has been fixed.
- PRTBIGOBJ
The Print Big Object tool assists in determining the large size
objects on your system. The correct ASP number was not always shown
on the report. This has been fixed.
- PRTSPLSTO
Print Spool Store is part of the Spool Store tool, which lets you
capture spooled files and retain them online. An exception occurred
when *DEV set as the job outq. This has been fixed.
- SAVRSTASP
Save and Restore ASP allows a library to be saved and restored from
one ASP to another. Fix added to prevent error message to
incorrectly be issued when parameter RSTASP set to *SAVASP.
- WRKSPLF2 and WRKSPLF3
It is now possible to release a spooled file that was in saved state
in addition to held state.
Incompatibilities
- No known incompatibilities have been introduced with this refresh.
2017-04-15 (R66)
New
- RTVQATTD
The Retrieve QATT File Description (RTVQATTD) command returns the
values needed to create a QATT source file. These are the name,
record length, and descriptive text of the file.
- VRYVRTDSP
The Vary Virtual Display command varies a virtual display or
displays off or on, whichever is requested.
Enhancements
- CHGTAAKEY
The Change TAA Key command allows the information in the TAALICENSE
data area to be changed. CHKTAAKEY was enhanced to include
additional fields and the ability to submit in batch.
- CHKSAVRST
Added CPF4168 to the list of messages reported.
- CHKTAP2
The Check Tape 2 command is similar to the CHKTAP system command,
with the additional function of sending an inquiry message to the
device's message queue and allows the user a Cancel or Retry
response. Additional information has been added to the reply
message, indicating which tape volume is currently mounted.
- CPYSPLFIFS
The Copy Spooled File to IFS command copies a spooled file to the
IFS as a stream file. Added support for AFPDS type spooled files.
- CPYTAA
The CPYTAA tool has been enhanced with two new keywords: CRTSRCF and
ESCAPE. The intent is to be able to reliably pull include members
from the archive during the building of a tool. This is part of our
effort to bring service programs into the tools. Includes will be
used to provide prototypes for TAATOOL APIs.
- CRTTAATOOL
The Create TAA Tool command has a new INCLIB parameter that accepts
up to three libraries in which to search for includes. This is part
of our effort to bring service programs into the tools. Includes
will be used to provide prototypes for TAATOOL APIs.
- ENDTAALIC
End TAA License ends the license to the TAA Productivity Tools by
placing an expiration date in the TAALICENSE data area on a
particular machine. ENDTAALIC was changed to show the machine serial
number, so the user can determine which machine the license was
ended on.
- PRTSRCSUM
The Print Source Summary command is similar to DSPFD with MBRLIST
option, but offers better formatting and several important options.
Change was made to include new QATT* source files.
- SCNALLSRC2
Scan All Source 2 command will scan for up to 20 arguments in all
souce files in one or more libraries. Additional file member
attributes retrieved and outfile support added.
- SCNSRC, SCNALLSRC, SCNALLSRC2
The member change date and member descriptive text were added to the
outfile. The model file is TAASRCFP and results in the outfile
SRCSRCP. The record format level identifier has changed as a result.
Fixes
- ADDJOBSCD2
The Add Job Schedule 2 command adds one or more job schedule entries
from the JOBSCDP file created by the CVTJOBSCDE TAA Tool to the
system job scheduling function. A fix was added to handle
descriptions that include apostrophes.
- CHKSAVRST
The CHKSAVRST command checks a job log that uses save/restore
commands and prints a listing with the completion messages and any
error diagnostics. Message handling was added for CPF4168.
- CHKTAAAUTL
The Check TAA Authorization Lists command checks to ensure that all
TAA Authorization Lists are set to PUBLIC EXCLUDE. Completion
messaging was changed to be more accurate.
- CPYFRMCSV
The Copy From CSV 2 command (CPYFRMCSV2) of the CPYFRMCSV tool was
maxing out at 13000 records in its temporary work file. This has
been changed to *NOMAX.
- CPYJOBSCDE
The Copy Job Schedule Entry command would complain about an invalid
date when copying entries that had *MONTHSTR as the scheduling date.
This has been fixed.
- CPYSPLFIFS
Copy Spooled File to IFS copies a spooled file to the IFS as a
stream file. Documentation was added stating that overprinting is
not supported and will cause duplicate data to appear.
- CVTIFS
The Convert IFS command converts directory entry attribute
information from the IFS and outputs the information to the IFSDIRP
data base file. An IBM i discrepancy in reporting authorization
errors for distributed directories caused a loop when such an error
was encountered. This manifested itself when processing directories
in QNTC. A workaround was added for these *DDIR types.
- CVTMSGQ2 Convert message queue 2 can convert a large number of
messages found in an external message queue to an outfile. Problem
was fixed where messages with blank message ids (such as inquiry
messages) were being removed incorrectly.
- CVTPGMA
The Convert Program Attributes command creates a data base file with
one record per program. New ACTGRP parameter was added to retrieve
activation group information.
- CVTQHST
There was a possibility that on very active systems CVTQHST could
produce an intermediate QPDSPLOG spooled file that hit its MAXRCDS
limit. This has been fixed.
- CVTSYSVAL
The Convert System Values command converts the spooled file output
from WRKSYSVAL to the SYSVALP file. A fix was added to correct how
long values are returned.
- DSPACTJOB2
The Display Active Jobs 2 command provides a display similar to
WRKACTJOB except that the user can only perform the Display action,
and jobs are sorted by CPU%. Fixed subscript out of bounds problem
when system had a very high number of jobs.
- DSPAUTLOB2
The Display Authorization List Objects 2 command expands DSPAUTLOBJ
functionality by 1) including IFS and DLS objects and 2) allowing a
generic name or all authorization lists. A fix was made to correctly
display lists with over 7500 entries.
- DSPDTAQ
The Display Data Queue tool displays or prints the entries of a data
queue and the data queue attributes. DSPDTAQ was fixed so it will
now correctly return up to 500,000 entries without throwing an
exception.
- DSPIFS
The Display IFS command provides a display or listing of IFS
objects. Documentation was corrected to state that directories are
always included in the listing.
- DSPOBJ
The Display Object command provides various DSPxxx commands for most
object types. Removed ALL and ALLUSR options from the OBJTYPE
parameter on the command.
- DSPOBJAUD
The Display Object Auditing command displays all audited objects in
a list of libraries or all libraries. The tool was fixed to give an
informational message if a single empty library is specified.
- ENDJOBWOL
The End Job With Locks command ends jobs with locks on a specific
object. A fix was added to correct the command name in the
documentation.
- MOVALLOBJ
The Move All Objects command moves one or more objects from one
library to another. SQLPKG support was removed from the command, as
SQL packages must remain in the library they are created in.
- PRTDEVCFG
The Print Device Config command prints a copy of the device
configuration objects and copies the contents to a source member in
a source file. Code was changed to delete the DSPOBJP file before
using it.
- RTVRELMTH
The Retrieve Relative Month command failed if it was "backing into"
December from a later month. This has been fixed.
- SAVLIBSAVF
The Save Library to Save Files command saves one or more libraries
to save files in a specified library. Command was fixed to handle
library lists longer than 256 characters.
- SCNGENSRC
The spooled file created by SCNGENSRC was named after the first
member processed for each candidate source file. It is now correctly
named after the source file itself. The USRDTA of the spool file is
now correctly specified as SCNGENSRC rather than SCNSRC. The number
of members scanned is now correct.
- SCNSRC
A minor fix was made to correct the number of members scanned when
used by SCNGENSRC.
- SNDDTAQ
The RCVDTAQ command of the SNDDTAQ tool might receive a MCH0603 (a
subscript or character string length violation) if the MAXLEN of the
queue was over 5000 and the entry being received was over 5000 in
length. This has been fixed.
Incompatibilities
- There are no known incompatibilities that have been introduced with
this refresh.
2016-11-15 (R65)
New
- DMOSUBF7
The Demo Subfile 7 tool provides a demonstration of using a subfile
for the display of an API call. Customers can take advantage of the
full source provided to create similar subfile based applications.
- DMOUIM
The Demo UIM tool provides a demonstration of using UIM for the
display of an API call. Customers can take advantage of the full
source provided to create their own uses for UIM-based applications.
- DSPACTJOB2
The Display Active Jobs 2 command provides a display similar to the
system WRKACTJOB command except that the user can only perform the
Display action against the jobs, and jobs are sorted by CPU %.
System and subsystem jobs are excluded.
- ENDJOBWOL
The End Jobs With Object Locks command ends all batch and
interactive jobs holding locks on a specified object.
- RTVRELMTH
The Retrieve Relative Month command will calculate and return three
data values based on the date specified in the DATE parameter,
offset by the number of months in the RELMTH parameter.
Enhancements
- CRTTAASRCF
The Create TAA Source Files tool was updated to include new source
files. The new source files are QATTC, QATTHTML, QATTUIM, QATTSRV,
and QATTSQL.
- CVTOUTQ
An ESCAPE keyword was added to the command. This is a *YES/*NO
value. The default is *NO. If *YES a CPF9898 escape message is sent
if the number of spooled files initially determined to be in the
queue does not match the number of records written. This can happen
if the queue is volatile.
- RTVQATTF
The Retrieve QATT Files tool was updated to include the new QATT
source files as part of our ILE direction. The new source files
being reported are QATTC, QATTHTML, QATTUIM, QATTSRV, and QATTSQL.
This enhancement affects both the RTVQATTF and PRTQATTF commands.
- SBMFTPCMD & FTP2
The Submit FTP Command command uses FTP2 to submit a simgle command
to run on another System i that is connected via FTP. OTHERCMDS2
parameter was added to support FTP commands longer than 255
characters.
Fixes
- CLROUTQ3
The Clear Output Queue 3 command clears selected spooled file from
an output queue. Fixed a problem where USRDTA was being cleared,
even when a specific value for the USRDTA parameter was specified.
- CPYTAADDS
The Copy TAA DDS command is primarily an internal tool used by
CRTxxx commands such as CRTSRCCTL. It allows CRTTAATOOL to occur
regardless of whether a full or demo license exists. Change made to
remove the dependency on the user needing to be authorized to
TAASRCACC list in order to retrieve encrypted DDS files. This allows
more tools to run in demo mode.
- CVTJOBLCK
The Convert Job Locks command converts the locks for a specific job
to an outfile. Dynamic allocation problem fixed to prevent null
pointer exceptions that were occurring. in the operating system.
- CVTMSGQ2
The Convert Message Queue 2 command converts the messages found in
an external message queue (such as QSYSOPR) to an outfile. Fixed
problem caused by exceptions from QGYCLST API call.
- CVTOUTQ
The Convert Output Queue command creates a data base file OUTQP with
one record per spooled file. Fixed to retry API call when API would
return partial list of OUTQs.
- CVTRCDLCK2
The Convert Record Lock 2 command builds an outfile of the record
locks held by a job. Fixed error when job was not found.
- DSPDBFDMG
The Display Data Base Damage command checks for damage in the data
base file descriptive information. Message text changed when no
objects found.
- PRTLIBANL
The Print Library Analysis command reports on how many objeccts
exist in a library or in a total system. Fix added to correctly
handle named ASPs.
- PRTPAGOF
The Print Page Of command allows you to re-print a spooled file
where you have printed 'Page n' and change the value to 'Page n of
n'. Fix added to handle large 'skip to line' values.
- RCLSTG2
The Reclaim Stroage 2 tool provides better documentation of the
results of RCLSTG and keeps the history where it may be conveniently
displayed. Fixed problem causing elapsed hours to display
incorrectly.
- RGZLIB
Th Reorganize Library command reorganizes all physical files in a
library or all user libraries. Fixes added to deallocate exclusive
locks on failure, and handle locks on members with all three allowed
values: EXCL, EXCLRD, or SHRUPD.
- RTVIFSEAUT
The Retrieve IFS Entry Authority command returns the current user's
authority to an IFS object. Fix added to handle user profiles with
no group profile.
- SCNALLJLG
The Scan All Job Logs command will scan all or selected job logs for
various criteria. Fixed issue when job spool files exceeded 9999 in
number.
- SCNSRC
The Scan Source command scans source files for a matching character
string or strings. Extraneous informational messages are now removed
from the job log.
Incompatibilities
- PRTSRCSUM
The Print Source Summary command was updated to report the new
source files for the *QATT value. Old files no longer in use were
dropped.
2016-04-15 (R64)
New
- WRKDBFUNIT
The Work Database File Unit tool allows you to inspect and set the
preferred storage unit for files on your system.
Enhancements
- ANZOUTQ
ANZOUTQ provides summary information for various attributes of
spooled files in an output queue. ANZOUTQ previously supported 999
unique attribute values for each attribute category. Enhancement was
made to now support 9998 unique values for each attribute. This
allows outqs with very large numbers of spool files to process
correctly.
- CHGJOBD2
CHGJOBD2 allows a change to one or more JOBD object types. An
Initial ASP group parameter was added.
Fixes
- AUDLOG
AUDLOG is a series of commands that let you work with QUAUDJRN
entries. Fixed a problem where MCH0601 erros occurred after a small
number of records were read. This issue was found using the
PRTAUDLOG command. Also fixed a problem where duplicate entries were
written when no new audit log entries were found. This issue was
found using the CVTAUDLOG command.
- CHGUSRPRF3
The Change User Profile 3 command is a front end to the CHGUSRPRF
command that allows a list of up to 300 user profile names or
generic names to be changed. Corrected the code so it will now allow
the values of SAME, SYSVAL, NONE, and ASSIST for the ATNPGM
parameter.
- CHKINACT2
CHKINACT2 tool is a series of commands that allow the ending or
disconnecting of jobs that have been inactive for a specified period
of time. Removed confusing informational message from job log.
- CPYPGMQM
The Copy Program Message Queue Message command copies one or more
messages from the current job's program message queue to an external
message queue. Fixed a problem where CPYPGMQM failed when the MSGQ
contained impromptu messages.
- CVTJRNA
CVTJRNA outputs the information that is found with WRKJRNA to three
separate data base files. Fixed code to handle exception when a file
is in use.
- CVTMSGQ2
CVTMSGQ2 allows a very large number of messages found in an external
message queue to be converted to an outfile. Code was changed to
correctly handle an empty message queue.
- CVTQHST
CVTQHST converts one or more QHST files to a normal data base file.
Code was fixed to handle file size of *NOMAX.
- CVTSYSSTS
CVTSYSSTS creates a data base file SYSSTSP with one record per main
storage pool. Fixed report so all digits of the unprotected storage
fields will display correctly.
- DLTUNULIB
DLTUNULIB deletes libraries with no objects, libraries whose objects
have never been used, or objects within libraries which have not
been used for specified number of days. Fixed logic error which
caused objects in libraries to be deleted which were outside the
specified date range.
- DSPALLSAVF
DSPALLSAVF displays or prints a listing of one, generic, or all save
files in one or more libraries. Changed file size limit to *NOMAX so
DSPOBJD will not give exception on files over 190000 records.
- DSPDLTSPC
DSPDLTSPC displays the amount of deleted record space that exists in
one of more libraries. Code was correctly check libraries found in
named ASPs, not just the base ASPs.
- DSPQHSTSIZ
DSPQHSTSIZ provides a simple listing of the QHST files in QSYS,
allowing a review of the QHST versions. Fixed a problem where the
1st message and last message times were duplicated in the outfile.
- DSPSAVSUM
DSPASAVSUM displays or lists a summary from one or more libraries
where objects are saved to. Corrected the all object authority check
whick occurred when certain library parameter options were chosen.
- FTP2
FTP2 allows the use of FTP without entering the FTP subcommands.
Fixed tool to correctly send TAA9897 exception when an FTP error is
encountered.
- LOCKWAIT
The Lock Wait tool provides commands to check for jobs in a LCKW
status as seen with WRKACTJOB. Added additional message monitors to
catch exceptions when jobs had ended, causing LOCKWAIT to terminate
unexpectedly.
- RCVMSGKEY
The Receive Message Key command receives a message from the job log.
It is meant to be used with RTVMSGKEY to process low level messages
in the job log. Fixed problem where RCVMSGKEY returned incorrect
results when called repeatedly with different options.
- RTVJOBA2
RTVJOBA2 allows retrieval of attributes for any job, supporting more
parameters than RTVJOBA. Fixed an problem where the active job
status was not always retrieved correctly. As a result the LOCKWAIT
tool failed in some cases.
- SCNALLSRC
SCNALLSRC provides a simple method of scanning all or some source
files in a library. Fixed problem where special characters were not
handled correctly.
- WRKIFS
WRKIFS is designed for those users who are trying to clean up the
IFS. User is now given a message when trying to roll past the
9,999th record, which is the maximum WRKIFS can display.
- ZIP
ZIP and UNZIP perform standard PC zip and unzip functions for
compressing/ decompressing data in the IFS. Fix added to correctly
handle multiple files.
Incompatibilities
- Commands that refer to previous releases (7.3 only)
All save commands, most compile commands, and commands that use *PRV
compiler support have had their TGTRLS parameters updated for 7.3.
While technically incompatible with previous release this is
consistent with 7.3 system changes. The following commands have been
affected: CHKTGTRLS, CMPOUTFILE, CRTBNDCL2, CRTBNDRPG2, CRTSFLPGM,
CRTSFLPGM2, CRTTGTRLS, RPLGENPGM, RPLOBJ, RPLMOD, RPLPGM, RPLSFLPGM,
SAVALLACT, SAVCHGACT, SAVJRNACT, SAVLIBIFS, SAVOBJIFS, SAVEONELIB,
SAVOWNOBJ, SAVRCVL, SAVSNDL, SAVSNDM, SAVSRCF, SBMSAVRCVL,
SBMSAVSNDL, SNDOBJMAIL.
2015-10-15 (R63)
New
- PRTPRFUSR
The Print Profile Users command lists profiles with *ALLOBJ
authority, along with profiles that have *USR authority or greater
to that profile. The report is generated into a spool file,
PRTPRFUSR.
Enhancements
- CRTDBFJRN
This command creates an externally described file that contains the
standard journaling fields. Support was added for PF38 files.
- FMTOPT
The FMTOPT tool provides a way to test options or command keys which
require several lines in a subfile application. Support was added
for 27 * 132 screen size.
- GENRANPWD
The GENRANPWD tool generates a random password, per selected
specifications. A new parameter, ALWUPR, was added.
- QRYF
QRYF simplifies the use of OPNQRYF. *UPD option added for type of
open to use.
- RTVPFSRC
This command retrieves the information from a physical file object
and writes a DDS source member. Support was added for PF38 files.
Fixes
- CAPSYSINF
CAPSYSINF captures all object, member, and IFS object information on
the system. Fixed an exception which occurred when no files found in
a library.
- CMPDTAARA
CMPDTAARA compares the contents of two data areas. Fixed a problem
with very small data areas.
- CRTTSTJRN
CRTTSTJRN is designed for writing test cases involving journaling.
Files already being journaled will now be bypassed instead of the
command ending.
- CRTVTP
The CRTVTP tool provides a simple interface for creating,
displaying, and deleting a virtual tape structure. Fixed a problem
where image catalog entries were exceeding the maximum size.
- CVTFD
The CVTFD command is similar to the system DSPFD command, but only
creates an outfile. Fixed a problem with an empty library generating
an exception. Reported as issue with CAPSYSINF.
- CVTIFS
CVTIFS converts directory entry attribute information from the IFS
and outputs the information to a data base file. When file errors
are detected on the convert, the files are skipped instead of ending
the command.
- CVTJOB
CVTJOB converts the information for one or more jobs to an outfile.
Fixed a problem where the current user field was not populated
correctly.
- CVTJOBFNC
The CVTJOBFNC checks for an active job with a specific function
type-description as seen on WRKACTJOB. Fixed a problem where the job
list was not being parsed correctly.
- CVTJOBLOG
CVTJOBLOG converts a job log to an outfile. Fixed a problem where
*LIBL not accepted as specified library. Also fixed a 7.2 problem
where first character of system name was truncated.
- CVTMSGQ2
CVTMSGQ2 converts messages found in an external message queue to an
outfile. The command has been fixed to correctly retrieve the
message queue name. Also fixed the opening and closing of message
file and added better exception handling.
- CVTOBJLCK
CVTOBJLCK converts the locks for an object to a data base file.
Fixed problem where OBJLCKP file was not being placed in specified
library.
- CVTSYSSTS
CVTSYSSTS converts output from WRKSYSSTS to a data base file with
one record per pool. CPU usage greater than 100% will now display
accurately up to 999%.
- CVTSYSVAL
CVTSYSVAL converts the spooled file output from WRKSYSVAL to a
physical file. Fix was added for a *DATE member name not being
accepted.
- DLTDBFDAT
DLTDBFDAT deletes data base file records based on a field value and
a specified date comparison. Fixed a decimal data error.
- DSPASPSTS2
The DSPASPSTS2 command provides an interactive display of the disk
units by ASP. Fixed an array indexing error.
- DSPOBJD2
DSPOBJD2 provides a different interface to the DSPOBJD command.
Fixed a problem retrieving large lists containing greater than 2000
objects.
- DSPSBMJOB
DSPSBMJOB displays a list similar to WRKSBMJOB, but the user cannot
perform actions against the jobs. Maximum number of jobs retrieved
changed from 2000 to 9999.
- JOBACG
The Job Accounting tool is a series of commands that lets you work
with the job accounting entries from the QACGJRN journal. Problems
fixed involved partial receivers leaving gaps in the sequence
numbers of the journal, and incorrect descriptions being captured.
- RCVDTAQ
RCVDTAQ is a front end to the system QSNDDTAQ command. Fixed a
problem with messages being left in the job log.
- RTVOBJLST
The Retrieve Object List command provides a large return variable
for a list of objects. The command has been fixed to correctly
retrieve large lists of over 90 objects. The problem was originally
reported as an issue with the CRTUSRPRF3 command, which uses
RTVOBJLST.
- RTVPFSRC
RTVPFSRC retrieves the information from an existing physical file
object and writes a DDS source member. Fixed a problem where
CRTDBFJRN (which uses RTVPFSRC) gave an exception when *CURDATE was
specified as date selection criteria.
- SCNIFS
SCNIFS scans one or more stream files for an argument. Fixed a
problem with files being left open resulting in an exception.
- SNDIFSMAIL
SNDIFSMAIL sends a note and an IFS attachment to one or more
recipients. Fixed an invalid character error when quotes were not
handled correctly.
- SNDTXTMAIL
SNDTXTMAIL sends a text message to one or more recipients. Fixed a
problem when sending message to group distribution list.
- SYSHST
DSPSYSHST is part of the System History tool, providing a simple
method of capturing and displaying important system information.
Fixed multiple problems with field lengths.
Incompatibilities
- There are no known incompatibilities that have been introduced with
this refresh.
2015-04-15 (R62)
New
- CVTTCPJOB
This tool examines a port to see which jobs are using it and reports
the current user profile for that job. This allows you to see what
users are signed onto the system through Telnet or FTP.
Enhancements
- CHKSAVRST
The CHKSAVRST command has been enhanced to include the CPD3775
message that says an object cannot be saved or restored.
- DLTDUPRCD
This has been enhanced to work with variable length character
fields.
- DSPOBJSIZ
DSPOBJSIZ has been enhanced to show the sizes for objects greater
than 10,000,000,000 bytes.
- SORTDBF
This has been enhanced to work with variable length character
fields.
Fixes
- CHKCMDDFT
This command checks to see if command defaults have been changed. It
was not reporting on some commands. This has been fixed.
- CPYFRMCSV
This command copies CSV files from IFS into a database file that
fits the data found in the CSV file. It was possible to run out of
space in temporary files used to analyze the CSV data if that CSV
file had more than 13000 rows. This has been fixed.
- CVTMSGQ2
The CVTMSGQ2 tool was getting an MCH0603 when working with extremely
long messages in the message queue. This has been fixed and the
message size capable of being handled has been increased.
- DSPDBFDTA
DSPDBFDTA lists *LAST as a valid value for the MBR keyword, but was
not accepting that value. This has been fixed.
- DUPFILFMT
This has been fixed to work with variable length character fields.
- JLGCTL
The display job log messages function of the JLGCTL tool was not
displaying messages correctly on 6.1 and 7.2. This has been fixed.
- RGZLIB
Under very rare circumstances the RGZLIB command could construct a
bad parameter value for the RBDACCPTH keyword on the RGZPFM command.
This has been fixed.
- RTVPFSRC
This command reconstructs the DDS source for a physical file from
its field definitions. It is used in a number of other TAA tools,
including CVTDBFJRN. It was constructing badly formed DDS when there
were long runs of non-blank characters. This has been fixed.
- SNDSPLMAIL
The SNDSPLMAIL command would fail if both SPLF(*SELECT) and
SENDTO(*INT) were specified on the command. This has been fixed.
- WRKSBSJOBQ
There was a bug that would occasionally result in a array index out
of bounds exception if there were more than 700 jobs in a job queue.
This has been fixed.
Incompatibilities
- There are no known incompatibilities that have been introduced with
this refresh.
2014-10-15 (R61)
New
- CPYSPLF4
The Copy Spooled File 4 command splits a spooled file into multiple
spooled files based on the number of pages specified. For example
you may have a report with 100 pages and you want to split into 10
spooled files of 10 pages each, or you may have a 20 page report and
you want a separate spooled file for each page.
- DSPSYSPTN
The Display System Partitions command displays information about the
current system partition and a summary of all system partitions.
- DSPUSRAUT4
The Display User Authority 4 command lists all objects in a library
that a named user is not authorized properly to. For example, if the
user should have *CHANGE authority to all objects in the library, a
line would be listed for each object where the user has 1) no
authority 2) is specified as *EXCLUDE, or 3) has only *USE
authority.
- SCNDBF
The Scan Data Base File command scans one or more members of data
base files for up to 20 strings. A listing is output with one line
for each time one of the strings is found in a record. The relative
record number of the record and the position where the string was
found is described.
- WRKOUTQ3
Work Output Queue 3 command is similar to the system WRKOUTQ
command, but supports additional capability such as all output
queues in a library or all libraries and a 'Position To' capability.
Enhancements
- CVTOBJD2
A new model file, TAAOBLIQ, has been added for use with the new
WRKOUTQ3 tool.
- PRTPAGOF
The PRTPAGOF command has been enhanced to preserve these of the
attributes of the original spool file: expiration date, duplex, user
defined data, start and end pages, LPI, and CPI.
- RSTSNDL
A new RSTASPDEV parameter has been added to the RSTSNDL command that
allows a library to be restored to a different ASP that the one
stored in the save file information. RSTSNDL is part of the SAVSNDL
tool.
- RTVNONSYS
In 7.2 the libraries QPTFOBJ1 and QPTFOBJ2 have been added to the
list of libraries to ignore when specifying *NONSYS for a list of
libraries on commands.
- SCNALLJLG
SCNALLJLG OUTPUTTYPE(*ONESPLF) has been enhanced to skip the
printing of job log headers that have no messages selected. This
brings the *ONESPLF option more in line with the *UNQSPLF option and
can significantly shorten the report.
Fixes
- APYRMTJRN
There was a bug in APYRMTJRN that would cause it to hang when
applying a large number of changes from a remote journal to the
objects named in that journal. This has been fixed.
- CHKIFSOPN
CHKIFSOPN was failing with conversion errors if the stream file
specified had a Unicode CCSID. It now checks for open conflicts by
doing a trial open in binary mode rather than text mode. This avoids
any attempt by the system to perform a text conversion on the open.
- CHKJOBSTS
The CHKJOBSTS command was occasionally supplying incorrect
parameters to the RTVJOBA command when multiple jobs were selected.
This resulted in an exception being thrown. This has been fixed in
this refresh.
- CHKMINRLS
The MINRLS parameter allowed V7R2M0 instead of V7R1M0. This has been
corrected.
- CHKSAVRST
The CHKSAVRST command would not work correctly if INPUTFILE(*DBFILE)
was specified. This change fixes CHKSAVRST to clear the DBFILE
member only if INPUTFILE(*JOBLOG) is specified.
- CLRLIB2
CLRLIB2 was issuing some confusing messages. These have been cleaned
up.
- CMPOUTFILE
On 7.1 this was allowing a compare against V5R3 which is not allowed
since there is no V5R3 compiler support. This has been corrected in
the 7.1 version of the tools.
- CPYSPLFIFS
CPYSPLFIFS was not handling fractional CPI settings correctly when
creating a PDF file. These are now being retrieved and set into the
PDF file.
- CPYTOFLAT
The size of the temporary file was set too low for some cases. A
size of *NOMAX is now used.
- CVTALLSPCA
The CVTALLSPCA command could only be run in a limited number of
environments It can now be run in all environments.
- CVTALLSPCA
CVTALLSPCA was receiving a size error (MCH1210) if there were
certain combinations of supplemental and group profiles specified on
a user profile. This has been fixed in this refresh.
- CVTAUDJRNE
The allowable codes contained several inaccuracies. These have been
updated to the codes specified in the security manual for 7.2.
- CVTFRMOUTQ
CVTFRMOUTQ will now fail quickly if the output queue being converted
has more than 32767 spool files. Each spool file generates a member
in the target database file. The limit on database file members is
32767.
- CVTIFS
A MCH3601 was fixed in the program TAAIFSAR when the *IFSLST special
value was used on the OBJ parameter. This has been fixed in this
refresh.
- CVTJOBLOG
CVTJOBLOG converts job log spool files into database files. It was
not parsing some job logs correctly and as a result was not creating
correct output. This has been fixed in this refresh. The problem
affected SCNALLJLG.
- CVTMBRD
If *ALLUSR was specified for the library on the CVTMBRD command then
no records would be output to the database file. This has been fixed
in this refresh.
- CVTMSGQ2
Under some circumstances a MCH1210 could occur when processing the
message queue. This has been fixed.
- CVTSPLSTO
CVTSPLSTO was failing with an MCH1210 when converting an output
queue containing more than 99,999 spool files. The limit has been
raised to 500,000 spool files. This command is part of the SPLSTO
tool.
- DLTIFS
DLTIFS was failing when it attempted to delete or release a held
spool file it created. This was only happening in a server job. This
is fixed in this refresh.
- DLTIFS2
DLTIFS2 was failing when it attempted to delete or release a held
spool file it created. This was only happening in a server job. This
is fixed in this refresh.
- DLTLIB2
DLTLIB2 was issuing some confusing messages. These have been cleaned
up.
- DSPAUDLOG2
DSPAUDLOG2 was incorrectly stating that no message ids existed for
audit log entries. While the newer audit log entries do not have
associated messages, the older ones still do. These are now
correctly displayed.
- DSPCLPCNT
DSPCLPCNT stopped after processing 900 members. This has been fixed
in this refresh.
- DSPCMDCNT
DSPCMDCNT stopped after processing 900 members. This has been fixed
in this refresh.
- DSPJRNRCVD
When over 500 journal receivers were attached to a specific journal,
the array index error would happen. The code has been fixed to
display a max of 9999 journal receivers. Any receivers found over
9999 will not be included in the output, but an exception will not
occur.
- DSPRPGCNT
DSPRPGCNT stopped after processing 900 members. This has been fixed
in this refresh.
- DSPTAPSIZ
On IBM i 7.1 DSPTAPSIZ was incorrectly reporting the size of the
files on tape if there were more than 50 files on that tape. This
has been fixed in this refresh.
- DSPUIMCNT
DSPUIMCNT stopped after processing 900 members. This has been fixed
in this refresh.
- PRTBIGOBJ
The model file, QSYS/QADSPOBJ, has a capacity of 190000 records
specified by the SIZE(100000 30000 3). The change creates the work
files in QTEMP using CRTDUPOBJ and then CHGPF with SIZE(*NOMAX).
- PRTLSTUSE
The model file, QSYS/QADSPOBJ, has a capacity of 190000 records
specified by the SIZE(100000 30000 3). The change creates the work
files in QTEMP using CRTDUPOBJ and then CHGPF with SIZE(*NOMAX).
- RTVAUDMDLF
The allowable codes contained several inaccuracies. These have been
updated to the codes specified in the security manual for 7.2.
- RTVPFSRC
RTVPFSRC could generate invalid DDS if used on a table that was
created using the SQL CREATE TABLE statement. In particular, null
strings were being generated for default values. This has been fixed
in this refresh.
- SAVSNDM
On 7.1 the SAVSNDM command allowed saving to V5R3 which is not
allowed by the system. This has been corrected in the 7.1 version of
the tools.
- SCNUPDSRC
SCNUPDSRC stopped scanning and replacing text in source files after
processing 900 members. This has been fixed in this refresh.
- SNDOBJMAIL
On 7.1 the SNDOBJMAIL command allowed saving to V5R3 which is not
allowed by the system. This has been corrected in the 7.1 version of
the tools.
Incompatibilities
- CVTAUDJRNE
The ZM entry type was removed as a valid value from the command. It
is not a valid audit journal entry type.
- RTVAUDMDLF
The ZM entry type was removed as a valid value from the command. It
is not a valid audit journal entry type.
- Commands that refer to previous releases (7.2)
All save commands, most compile commands, and commands that use *PRV
compiler support have had their TGTRLS parameters updated for 7.2.
While technically incompatible with previous release this is
consistent with 7.2 system changes. The following commands have been
affected: CHKTGTRLS, CMPOUTFILE, CRTBNDCL2, CRTBNDRPG2, CRTSFLPGM,
CRTSFLPGM2, CRTTGTRLS, RPLGENPGM, RPLOBJ, RPLMOD, RPLPGM, RPLSFLPGM,
SAVALLACT, SAVCHGACT, SAVJRNACT, SAVLIBIFS, SAVOBJIFS, SAVEONELIB,
SAVOWNOBJ, SAVRCVL, SAVSNDL, SAVSNDM, SAVSRCF, SBMSAVRCVL,
SBMSAVSNDL, SNDOBJMAIL.
2014-01-15 (R60)
New
- CHGMAXMBR
The Change Maximum Members command changes the number of maximum
members for one or more data base files in a library based on a
specified percentage. Only data physical files are processed. The
command defaults to 'check' meaning no changes occur unless
ACTION(*CHANGE) is specified.
- CHGMSGQ2
The Change Message Queue 2 command allows a change to one or more
*MSGQ object types. Not all of the CHGMSGQ parameters are supported.
CHGMSGQ2 simplifies making mass changes to *MSGQ objects. For a more
complete understanding of the parameters, see the CHGMSGQ command
help text. A *MSGQ object owned by one of the system profiles may
not be changed.
- CHGOBJD4
The Change Object Description 4 command provides a general purpose
solution when a program wants to prompt for a CHGxxx command. Only
typical object types and attributes are supported. Assuming you have
provided a proper interface to CHGOBJD4, the command will complete
normally whether the change has been made, the command prompt was
cancelled, or the command failed. The ESCMSGID parameter will be
blank if a successful change was made.
- CHGSAVF2
The Change Save File 2 command allows a change to one or more save
files. Not all of the CHGSAVF parameters are supported. CHGSAVF2
simplifies making mass changes to save files. For a more complete
understanding of the parameters, see the CHGSAVF command help text.
A save file owned by one of the system profiles may not be changed.
- CHGUSRPWD3
The Change User Password 3 command allows a command change of a user
password that ensures the QPWDxxx system value requirements are met.
For example, if you have specified that a required digit exist by
use of QPWDRQDDGT. This allows a change to be made by other than the
interactive user that still follows your password requirements.
CHGUSRPRF can change a password, but does not check the system
values.
- CNFDLTARA
The Confirm Delete Data Area command provides a confirmation display
and allows F6 to delete the data area. The attributes of the data
area are shown along with the Both *CHAR and *DEC (up to 15 digits)
data areas are supported. The QWCRDTAA API is used.
- CPYDIRE
The Copy Directory Entry command retrieves information about the
From User ID from the Directory Entries (as seen with WRKDIRE) and
prompts for a new entry using ADDDIRE. The existing values for the
From User ID are used as the defaults for ADDDIRE with the
exceptions of the USRID, USER, and SYSNAME parameters.
- CPYSHFSPLF
The Copy Shift Spooled File command allows you to shift the data in
a spooled file either left or right and re-prints the spooled file.
The file must be capable of being copied by CPYSPLF (this excludes
files with graphic characters).
- CVTALLSPCA
The Convert All Special Authorities command creates an outfile of
all special authorities for one or more users. By default, multiple
records are written for each user profile: one record for the user,
one for his group profile (if any), one for each supplementary group
(if any), and a summary record combining all special authority
information.
- DEBUG
The Debug tool is not code, but rather a technique to assist in
debugging. It can also be used for any function where you are
repeating several commands on a command entry display. It allows you
to quickly execute a command that you had entered earlier in an
interactive job. The Debug tool uses the FAVCMD tool to store the
commands.
- DSPALLDTAT
The Display All Data Types command lists or displays the data types
that are to be included or excluded from a file or files. For
example, you can display all fields that have a W (variable length)
data type for files in a library.
- DSPALLSPCA
The Display All Special Authorities command displays the special
authorities for an individual user, the special authorities for his
group profile, and the special authorities for each of his
supplemental profiles. This allows a review of what special
authorities the user is allowed to use.
- DSPDBFJOIN
The Display Data Base Join Files command displays or lists one or
more join files in one or more libraries. The From and To file
information is provided along with the name of the keys from each
file.
- DSPDUPKEY
The Display Duplicate Key command checks a keyed file that has not
been specified for Unique keys to see if any duplicate keys exist.
The file is read in keyed order per the key fields defined for the
file and compared to the previous record. The relative record
numbers of any duplicates are described.
- DSPMSG2
Display Message 2 allows several selection criteria to minimize the
number of messages that would be displayed or listed. For example,
you can display by message ID, message type, job, user, start/end
date/time, or the sending program. The DSPMSG2 command may be used
on any message queue, but would most likely be used with QSYSOPR.
- FIXALLSRC
The Fix All Source command provides a method of making mass changes
to member data in a source file based on a 'From value' found in the
source. Any type of source is valid to be changed. Because
ACTION(*CHECK) is the default, no changes will be made allowing a
review of what would be made by ACTION(*CHANGE).
- FNDUSRATR
The Find User Attribute command finds objects that have a named user
attribute or any user attribute. A listing is displayed or output.
User attributes allow a further identification of objects.
- HLDJOBUNTL
The Hold Job Until command allows you to release a held job at a
specific time. You can either use HLDJOB to hold the job or submit
the job with HOLD specified. The job being held cannot be an
interactive job. You can release the job either in the current day
or the next day. HLDJOBUNTL may be helpful when you want to hold a
job for a period of time and avoids having to remember to release
the job.
- LOCKWAIT
The Lock Wait tool provides commands to check for jobs in a LCKW
status as seen with WRKACTJOB. RUNLCKWAIT provides job log messages
if jobs are waiting for a lock. SBMLCKWAIT submits a never ending
batch job that sends messages to a message queue if jobs are locked.
The LCKW value can be caused by either a job waiting for a record
lock or an object lock.
- MTNJRN2
The Maintain Journal 2 command provides the ability to delete old
receivers (and add a new receiver) to one or more journals. Both
system and user journals may be specified.
- RMVMSGD2
The Remove Message Description 2 command removes a range of message
IDs or all messages from a message file. The default provides a
listing of the message IDs that would be removed if ACTION(*REMOVE)
was specified.
- RTVJOBCMP
The Retrieve Job Completion tool retrieves the completion status for
a job. Two solutions are provided: 1) RTVJOBCMPM (Retrieve Job
Completion Message) and 2) RTVJOBCMPA (Retrieve Job Completion
Accounting). Both solution provide for a delay time and a number of
iterations to allow a program to wait for a reasonable time.
- SNDPGMMSG4
The Send Program Message 4 command is a subset front end to
SNDPGMMSG which allows a message ID to be sent from a message file
to a message queue. The system SNDPGMMSG command may only be used in
a CL program. SNDPGMMSG4 allows any environment and can be helpful
when testing either how the message text will appear or to place a
message with an ID in a message queue.
- WRKIFS2
The Work IFS 2 command is designed for a review of IFS entries, but
does not allow any changes to be made. Several selection and
sequencing options exist. The WRKIFS command is similar, but allows
removal of entries and access to WRKLNK.
Enhancements
- CHGALLSPLF
A new parameter has been added to allow a change to USRDTA.
- CHGOBJAUT
A new parameter has been added to allow selection on the object
attribute.
- CHKINACT
A new parameter has been added to SBMINACT to allow the job to run
during a specific time of day.
- CVTLIBOBJA
A new parameter has been added to prevent the authorizations from
the library object to be output.
- ENDDUPJOB
The maximum number of duplicate jobs that can be ended on one
command has been raised to 546.
- FNDSRCMBR
A new value for the OUTPUT parameter will allow an immediate display
of the spooled file output.
- FNDSRCTXT
A new value for the OUTPUT parameter will allow an immediate display
of the spooled file output.
- FTP2
The size of the RMTUSER and RMTPWD has been increased from 30 to 100
characters. The same changes have been made to SAVSNDL, RCVSNDL,
SAVRCVL, SBMSAVRCVL, SAVSNDM, RCVSNDM, and SBMFTPCMD
- MTNJRN
A new value *TEST has been added to the DLTOLDRCVR parameter to
allow testing of what MTNJRN would do.
- RTVJOBSTS
A new parameter has been added for a job list of up to 546 jobs.
- RTVSYSPTN
Many new parameters have been added to allow other information to be
returned about the partition definition and current values.
- WRKF2
A new option has been added for CLRALLPFM.
Fixes
- CHGLIBOWN
The OMITOWN parameter did not omit the object in all cases. The
OLDOWN parameter was not handled properly. These errors have been
corrected.
- CHGOBJAUT
If a generic user name was entered and more than 50 existed, the
command failed. The first 50 are processed and an escape message is
now sent.
- CVTIFS
If the ASP value exceeds 99, the command failed. A new field IFASPL
has been added as *DEC LEN(3 0) to both outfiles supported by
CVTIFS. If the ASP number is greater than 99, the value returned for
IFOASP will be -1 and the actual value will be in the IFASPL field.
If the value is 99 or less, the IFOASP and IFASPL values will be the
same.
- CVTLIBCNT
The size of the TAATMPSPC2 user space was increased.
- CVTLIBOBJA
An error occurred when library QTEMP was attempted to be processed.
A restriction has been added so that library QTEMP may not be
specified directly and is bypassed when attempted with a generic
name (QT*) or with all libraries.
The command failed with duplicate keys if all *LIB object types in
QSYS were specified. This has been corrected.
- DLTIFSDIR
The code did not properly handle apostrophes in the name. This has
been corrected.
- DSPLIBAUT
In some cases *GROUP appeared as the user name rather than the owner
name. This prevented BYPOWNER(*YES) from eliminating the owner line.
The owner name is now used if *GROUP appears in the data being read.
- ENDDUPJOB
The command failed on a large number of duplicate jobs. A limit of
120 can be processed on each use of the command.
- MTNJRN
If SAVINQMSG(*BYPASS) was specified, the saved journal receivers
eligible for deletion were not being deleted. This has been
corrected.
- RTVIFSED
The command failed if the ASP number exceeded 99. A new return
variable ASPL was added with *DEC LEN(3 0). If the ASP number is
greater than 99, the value returned will be -1 and the actual value
will be in the ASPL return parameter. If the value is 99 or less,
the ASP and ASPL values will be the same.
- SPLARC
The open date of the spooled file was not converted correctly and
the current date was used instead. This has been corrected.
- UPSMON
The ENDUPSMON command was not setting the QUPSMSQ system value back
to QSYSOPR in QSYS. This has been corrected.
- WRKIFS
The F5 option was failing. Several options were failing if quotes
were in the name. These errors have been corrected.
Incompatibilities
- CHKJOBMSGW
A subsystem library name or *LIBL must now be entered.
- PRTLIBANL
The default print file is now TAAPRT1 to avoid conflicts with a user
QPRINT printer file.
2013-10-15 (R59)
New
- CHGDBFINC
The Change Data Base Increments command changes the number of size
increments for one or more data base files in a library based on the
current percentage of records and a specified new percentage. Only
data physical files are processed. The command defaults to 'check'
meaning no changes occur unless ACTION(*CHANGE) is specified.
- CHGJOBQ2
The Change Job Queue 2 command allows a change of one or more *JOBQ
object types. CHGJOBQ2 simplifies making mass changes to *JOBQ
objects. For a more complete understanding of the parameters, see
the CHGJOBQ command help text. A *JOBQ object owned by one of the
system profiles may not be changed.
- CHGLF2
The Change Logical File 2 command allows a change of one or more
logical files. Not all parameters from CHGLF are supported. CHGLF2
simplifies making mass changes to logical files. For a more complete
understanding of the parameters, see the help text for CHGLF. A
logical file owned by one of the system profiles may not be changed.
- CHKMBRSPE
The Check Member Spelling command checks the spelling of the words
in the member text for all members in one or more files in a
library. Both source and data members are checked. The command
defaults to use the dictionary provided by the TAA Productivity
Tools. A specific dictionary or multiple dictionaries may be used.
- CHKOBJSPE
The Check Object Spelling command checks the spelling of the words
in the object text for one or more objects in a library. The command
defaults to provide the dictionary provided by the TAA Productivity
Tools. A specific dictionary or multiple dictionaries may be used.
- CHKSRCTYP3
The Check Source Type 3 command checks a value to see if it is a
valid source type as described by the Programmer Menu. TXT and TXT38
are optional.
- CHKTAAQSYS
The Check for TAA Commands in QSYS command checks for TAA command
names that have a duplicate name in QSYS. This is intended to assist
in identifying if a new system command uses the same name of an
existing TAA command.
- CHKUSRGRP
The Check User for Group command checks if a user profile is a
member of a named group either by the GRPPRF or SUPGRP attributes of
the profile. TAA9891 is sent as an escape message if the user
profile is not a member of the group. No completion message occurs
if the user profile is a member.
- CMPLIBAUT
The Compare Library Authority command compares the Create Authority
for a library to the objects within the library. If the authority of
the *PUBLIC user differs from the library Create Authority, the
object is listed. Libraries with an Authorization List used for the
Create Authority are not supported.
- CRTGENOBJ
The Create Generic Objects command allows you to create a number of
generic objects with consecutive names like ABC002, ABC003, etc of
any object type. The first object must exist in the library where
the duplicates will be created.
- CVTJOBLOG2
The Convert Job Log 2 command creates an outfile of one record per
batch job that was submitted and has completed. Selection on the
completion code (defaults to abnormal job end) may be specified. The
command is a slow runner, but the outfile can be used to help
understand the failures that have occurred. The command is English
language dependent.
- CVTMONEY
The Convert Money tool allows a CL program to calculate such
functions as how much money is owed each month on a typical mortgage
calculation. Several commands are provided.
- DLTUNULIB
The Delete Unused Library command deletes libraries that have
1. no objects,
2. all objects within the library have never been used, or
3. the object within the library with the most recently last used
date has not been used for a specified number of days.
The default is ACTION(*CHECK) so that only a listing is output of
what would be deleted.
- DSPDUPJBQE
The Display Duplicate Job Queue Entries command displays or lists
job queue names that are duplicates in different subsystems.
DSPDUPJBQE can be used to help identify problems where the same job
queue is used
- DSPGRPPRFI
The Display Group Profile Indicator command displays whether a
profile is a group profile (has members in its group). You must have
*ALLOBJ authority to use DSPGRPPRFI. Use the DSPGRPPRF command to
list the members of the group.
- DSPNONUSE
The Display Non Use command command lists objects that have not
never been used along with size information. This can assist in
cleanup of the system. Because of the way last used information is
handled on multi-member data base files, the information may not be
accurate on multi-member files.
- DSPOBJEXCP
The Display Object Exceptions command lists one or more objects that
are saved with storage freed, locked, damaged, or where the storage
requirement has overflowed the ASP. Multiple libraries may be
searched.
- DSPOWNOBJ
The Display Owned Objects command is similar to the system DSPUSRPRF
TYPE(*OBJOWN) function, but provides size, last used date, and text
description also. A summary may also be made by either library or
object type.
- DSPUNQKEY
The Display Unique Key command displays the number of unique values
in the access path fields for a data keyed file (non source). The
file does not have to have unique keys. The system provides the
number of unique values for the first 4 key fields of a file. This
means a count of the unique values for key 1, key 1-2, key 1-3, and
key 1-4. One line is listed for each member. The information can
provide a better understanding of the data.
- DSPUNQKEYT
The Display Unique Key Totals command displays or lists members in
one or more data files in a library. The number of unique keys for
the first 4 keys of each keyed access path are listed. This can
provide a better understanding of the data that makes up the keys of
the file.
- DUPFILFMT2
The Duplicate File Format 2 command duplicates a file from a
physical file to a new file with the same format as the original
file. The user must have *USE rights to the file being duplicated.
This differs from CRTDUPOBJ which requires *OBJMGT authority.
- MOVALLOBJ
The Move All Objects command moves one or more objects from one
library to another. An option allows a determination of what
processing should occur if the object already exists in the To
library. The default moves only objects that do not exist in the To
library.
- RMVTRLNULL
The Remove Trailing Nulls command will remove trailing nulls (X'00')
from an input variable and convert them to blanks (X'40') values.
The input variable may be up to 5000 bytes in length. The output
variable must be 5000 bytes. A start position may be named. No
embedded nulls are changed. Trailing blanks are ignored.
- RTVGRPPRFI
The Retrieve Group Profile Indicator command retrieves a *YES/*NO
for whether the specified user profile is a group profile. You must
have *ALLOBJ special authority to use RTVGRPPRFI.
- RTVNXTNAM
The Retrieve Next Name command takes a name value such as 'ABC0001',
adds 1 to the digit portion, and returns the next name 'ABC0002'.
The number portion of the name may contain 1-9 digit positions, but
must be in the trailing position of the name. A rollover such as
from a name 'ABC9999' causes an escape message. RTVNXTNAM may be
used for objects, members, or your own internal naming convention.
- SCNCLPTAA
The Scan CLP TAA Commands command scans the outfile created by
CVTCLPCMD for TAA commands. CVTCLPCMD converts all commands found in
a source file to one record per command in an outfile. SCNCLPTAA
lists each command found in the file that exists in TAATOOL along
with the source member and sequence number within the source.
- SCNDDSSRC
The Scan DDS Source command scans DDS source for various values such
as a string of text in the Functions field such as the word 'JOIN'.
All selection criteria must be met to print a record. The command
can be helpful when searching for some values that have been used
previously.
- SCNMBRA
The Scan Member Attributes command scans one or more data base
members in a library for attribute values. For example, you can scan
for the number of members with more than 1000 records or all members
that have a keyed access path. This acts as a simple query to
determine the value of attributes of members.
- SCNSAVFA
The Scan Save File Attributes command scans one or more save files
for attribute values. For example, you could scan for all save files
that have more than 100 records. This acts as a simple query to
determine the value of attributes of save files.
- SWPLIBLE2
The Swap Library List Entry 2 command allows a swap of 2 libraries
on the user portion of the library list. For example, if both QGPL
and QTEMP are in the user portion of the library list and should
trade places, the SWPLIBLE2 will make the swap.
Enhancements
- CHGLIBOWN
The code has been improved to allow more changes when other than an
*EXCL lock is held.
- CHKJOBMSGW
The SBS parameter now allows a qualified name. If no library
qualifier is entered, the command operates as before.
- CMPSRC
A generic new member name is now supported.
- CPYCHGMBR
A new parameter has been added to allow a generic member name.
- CRTDBFJRN
Better error messages have been added for when the user is not
authorized.
- CVTJOBLCK
A second version of the command (CVTJOBLCK2) has been added which
uses the QWCRJBLK API. Additional fields exist in the outfile vs
CVTJOBLCK.
- CVTOUTQD
The name of the remote output queue has been added.
- CVTRMTOUTQ
The name of the remote output queue has been added.
- CVTWRKACT
The SBS parameter now allows a qualified name. If no library
qualifier is entered, the command operates as before.
- DLTGENLIB
A new parameter has been added to allow the comparison date to be
entered in terms of number of days.
- DSPARACDE
Updates have occurred and to PRTARACDE also.
- DSPTAACAT
Several tool text descriptions have been improved to differentiate
between tools such as CVTOBJD and CVTOBJD2.
- LOOKUP
A new parameter has been added to allow the search to be ended if
the next entry to be compared is blank.
- RTVDIRE
The command has been enhanced to retrieve substantially more data
than previously. As a result, the second element of the USRID
keyword is now required and can no longer be *FIRST. The third
element of the USRID keyword has been dropped. The RTNADDR keyword
has been dropped as well.
- RTVOUTQA
A new parameter has been added for the long name of a remote output
queue.
- TAASECURE
The documentation member has been enhanced to describe programs that
adopt and why adoption is used.
Fixes
- CPYFRMCSV
If the created file definition exceeded 9999 bytes, the CPYFRMCSV2
command failed. This has been corrected by changing to an RPGLE
program which allows a 32000 byte input file length.
- CPYJOBSCDE
If SCDDAT(*MONTHEND) was specified, the command failed with a bad
date separator. This has been corrected.
- CRTUSRSPC
A new parameter exists that defaults to *YES for auto extending of
the space. The assumption of *NO previously caused some APIs to fail
such as QUSLJOB used by CVTWRKACT.
- CVTIFS
If the object is a symbolic link, the object it resolves to is now
used.
- CVTTAPSAVD
The size information was incorrect (an extra zero was added). The
size information for members is now set to 0. In some cases the
member record contained invalid data. These errors have been
corrected.
- ENDDUPJOB
The command failed because of an invalid job name caused by the
incorrect offset. This has been corrected.
- JOBACT
In some cases the STRJOBACT command failed trying to resend a
message that did not exist. This has been corrected.
- MOVSPLF
The command failed if more than 100,000 spooled files were moved.
This has been corrected.
- RTVCMDSRC
For certain commands, RTVCMDSRC looped internally. This has been
corrected.
- RTVJOBSTS
The DUPJOBRQS(*LAST) function was returning blanks. This has been
corrected. The maximum jobs returned is 120 not 200.
- WRKUSRAUD
The text for the user was incorrect when the detail display option
was used.
- WRKVTP
If the image catalog was allocated (eg being saved to), the command
failed. It now displays *NOTAVL.
Incompatibilities
- RTVDIRE
The command has been enhanced to retrieve substantially more data
than previously. As a result, the second element of the USRID
keyword is now required and can no longer be *FIRST. The third
element of the USRID keyword has been dropped. The RTNADDR keyword
has been dropped as well.
2013-07-15 (R58)
New
- CHGOUTQ2
The Change Out Queue 2 command allows a change of one or more *OUTQ
object types. Not all keywords used by CHGOUTQ are supported.
CHGOUTQ2 simplifies making mass changes to *OUTQ objects. For a more
complete understanding of the parameters, see the CHGOUTQ command
help text. An *OUTQ object owned by one of the system profiles may
not be changed.
- CHGPGM2
The Change Program 2 command allows a change to one or more *PGM
object types. Not all of the CHGPGM parameters are supported.
CHGPGM2 simplifies making mass changes to *PGM objects. For a more
complete understanding of the parameters, see the CHGPGM2 command
help text. A *PGM object owned by one of the system profiles may not
be changed.
- CHKTAACHG2
The Check TAA Change 2 command checks the last change date of
objects in TAATOOL against the date the TAA version was installed.
Any objects changed after the install date are listed. This allows a
review of what has changed since the TAA Productivity Tools were
installed. An *ALLOBJ user is required.
- CMPIFSED
The Compare IFS Entry Description command compares the major
attributes of two IFS objects. A listing is produced if any
differences exist. An escape message is issued if differences exist
and the command is run in batch or OUTPUT(*PRINT) is specified.
- CMPSGNUSE
The Compare Signon to Last Used command allows a check to see if a
profile is being used after the last signon date. This could occur
if the profile name has not signed on since it was used such as in a
SBMJOB command or a job schedule job. User profiles that are not
permitted to signon will normally appear.
- CMPSTMF
The Compare Stream File command compares two stream files and lists
the From and To records that differ. The named stream files are
copied to 9999 byte files in QTEMP and compared. If differences are
found, the data from each record is listed up to 100 positions.
- CVTDISTANC
The Convert Distance command allows a conversion from one type of
value such as meters to a different type such as miles. The input
value may be up to 9 digits with 2 decimals. The output value may be
any of 15/0, 15/2, or 15/5. Conversions can be made for millimeters,
centimeters, meters, kilometers, inches, feet, yards, miles, cable
lengths, fathoms, and furlongs.
- CVTOBJAUTD
The Convert Object Authority Description command converts individual
authorities to an authority description of *ALL, *USE, *CHANGE,
'USER DEF', or *EXCLUDE. This can be helpful when dealing with an
outfile such as that used by DSPUSRPRF TYPE(*OBJAUT).
- CVTOUTQDTQ
The Convert Output Queue Data Queue command converts the entries
sent by the system to a data queue if the DTAQ parameter is
specified on CRT/CHGOUTQ. This allows a determination of spooled
files that were output as opposed to the print accounting function
which captures only those files that were actually printed.
- CVTRCDLCK
The Convert Record Locks command converts the record locks from all
jobs holding record locks on a specific file/member. You must have
*JOBCTL special authority to use CVTRCDLCK. The outfile is always
RCDLCKP with a format name of RCDLCKR. The model file TAADBJMP in
TAATOOL is used.
- DLTOLDOBJ
The Delete Old Object command deletes old objects in a library based
on the create date of the objects and the number of days specified.
If your approach is to create temporary objects in a permanent
library and cleanup periodically based on the create date, DLTOLDOBJ
may be useful.
- DSPCMDKWD2
The Display Command Keyword 2 command displays or prints a simple
list of the keywords used by a command. QSYS and TAATOOL command
information is supplied in TAATOOL. User commands must be converted
to a file using CVTCMDKWD.
- DSPMSGDAT
The Display Message Queue by Date command provides a simple listing
of the messages in a message queue by date and time. This provides a
review of how old messages are in a message queue.
- EDTDTAQ
The Edit Data Queue command allows editing of character data in a
non-keyed data queue with a maximum entry length of up to 5000
bytes. An interactive display is used for editing and updates,
deletions and new entries may be made.
- RMVENDPER
The Remove Ending Period command removes an ending period ('.') from
an input text value if it exists and returns a variable without the
ending period. This can be useful when resending escape messages
that may have an ending period.
- RNMGENOBJ
The Rename Generic Object command allows a rename of generic objects
in a named library. The new generic name value must be less than or
equal to the length of the existing generic name. Any characters in
the name of an object after the generic name are carried over to the
new name. A listing is produced including any errors found.
- RTVFLROBJ
The Retrieve Folder Object command allows the retrieval of
information about a *FLR object when only the system object name
that exists in the QDOC library is known. The system object names
may appear from a function such as when using the DSPOBJD outfile.
These names do not relate to a user recognizable name. RTVFLROBJ
provides a translation from the *FLR object name to the information
displayed by WRKFLR.
- RTVJOBSTSL
The Retrieve Job Status Loop command allows the current job to delay
until another job is in a specified status. For example, if you
submit a batch job, you may not want to continue in your program
until the batch job is active or on an output queue.
- SCNEXTDTA
The Scan and Extract Data command scans a string of data for a value
and returns the first n bytes prior to a blank after a successful
scan. For example, if you are scanning message text, you might want
the value after the word 'library '.
- SORTSRC
The Sort Source command allows a range of source statements in a
source member to be sorted. The output is always to the SORTSRC
member of the TAASORTSRC source file in QTEMP. The default is to
sort on the entire source data value. From/To positions may be
specified. You may then use the SORTSRC member to copy to wherever
it is needed.
- WRKUSRAUT
The Work User Authorizations command provides a work display for a
user profile's specific authorizations. This excludes the user's
owned objects. The outfile from DSPUSRPRF TYPE(*OBJAUT) is used
internally to provide the basic information. Options exist to
display the object description, display the authorizations, and edit
the authorizations.
Enhancements
- ADJAPOST
A new ACTION values was added for doubling the number of quotes and
then adds 2 more.
- AUDLOG
A new parameter has been added to allow the work file library to be
named which could be in an ASP.
- CPYUSRPRF
A new parameter OWNER has been added to allow the From User Profile
to be a member of a group where the objects should be created as
owned by the group.
- RSTAUTL
A new parameter has been added to allow for the case where the
library on the target system does not exist. This will cause flags
on the listing as opposed to the command ending with an escape
message. Both the SAVAUTL and RSTAUTL tools now support *DIR, *STMF,
*DOC, and *FLR object types.
- SNDSPLMAIL
The SUBJ parameter may now be entered and has been increased to 44
bytes. The name of the attachment will be the spooled file name plus
'.txt'. Spooled file names longer than 8 bytes will be truncated to
8 for the attachment name.
The same enhancement has been made to SNDIFSMAIL, SNDSPLPDF, and
SNDOBJMAIL.
- SWPUSRPRF
The size of the CMD parameter has been increased to 32,000 to allow
for any expansion done by the command analyzer.
- TAAMSGF
The TAA9855 message ID used for completion messages now supports a
second level capability which defaults to '&2'. The TAA9868 message
has been added which is a duplicate of CPF9898 to allow a second
level capability.
- WRKALLSPLF
The job name has been added to the Alternate display.
- WRKJOB2
The job name and user name may now contain generic values.
Fixes
- CVTSYSVAL
The command failed when the last page had no system values. This has
been corrected. The QALWOBJRST multiple choices are now supported as
well as on CMPSYSVAL. This change applies to V6R1 and following
releases.
- DUPMSGD
A single value for DMPLST was duplicated. Up to 15 values are now
supported.
- DYNMNU
When Option 6 (Test Dynamic Menu) was used from GO DYNMNU, the group
profile of the user was used instead of the current user profile.
This has been corrected.
- MTNJRN
If a receiver is partially saved, the SAVINQMSG(*BYPASS) option will
now bypass the receiver.
- PRTPTFSUM
The command failed if the number of outfile records exceeded 13,000.
This is now handled in the TAA program to allow *NOMAX.
- RMVOLDMSG
When *ALL message queues in a library were specified, not all
message queues were processed in some cases. This has been
corrected.
- RTVMTHNAM
The command failed for some dates in February. This has been
corrected.
- WRKALLSPLF
The error message stating that more than 9999 spooled files exist
was not being displayed. This has been corrected. The message that
occurred when more than 16GB occurred in the space is now ignored as
later messages describe an error.
Incompatibilities
- SNDSPLMAIL
The SUBJ parameter was changed from a default of *NOTUSED to a
required parameter of 44 characters. The value becomes the subject
seen by the receiving user. The first 8 characters of the spooled
file name is concatenated with '.TXT' to become the name of the
attachment.
The same change has been made to SNDIFSMAIL, SNDSPLPDF, and
SNDOBJMAIL.
2013-04-15 (R57)
New
- CHGCLS2
The Change Class 2 command allows a change to one or more *CLS
object types. CHGCLS2 simplifies making mass changes to *CLS
objects. For a more complete understanding of the parameters, see
the CHGCLS command help text. A *CLS object owned by one of the
system profiles may not be changed.
- CHGDSPF2
The Change Display File 2 command allows a change to one or more
display files. Not all of the CHGDSPF parameters are supported.
CHGDSPF2 simplifies making mass changes to display files. For a more
complete understanding of the parameters, see the CHGDSPF command
help text. A display file owned by one of the system profiles may
not be changed.
- CHGDTAQD2
The Change Data Queue Description 2 command allows a change to one
or more *DTAQ object types. Not all of the CHGDTAQD parameters are
supported. CHGDTAQD2 simplifies making mass changes to *DTAQ
objects. For a more complete understanding of the parameters, see
the CHGDTAQD command help text. A *DTAQ object owned by one of the
system profiles may not be changed.
- CHGJOBD2
The Change Job Description 2 command allows a change to one or more
*JOBD object types. Not all of the CHGJOBD parameters are supported.
CHGJOBD2 simplifies making mass changes to *JOBD objects. For a more
complete understanding of the parameters, see the CHGJOBD command
help text. A *JOBD object owned by one of the system profiles may
not be changed.
- CHKDUPSPLF
The Check Duplicate Spooled File command checks an outfile created
by CVTOUTQ for duplicate spooled files. The check is made on the
qualified job name, the spooled file name, and spooled file number.
CHKDUPSPLF is intended for the case where the system may be creating
duplicates.
- CHKIFSSAV
The Check IFS Save command displays or prints a listing of IFS
objects that need to be archived (saved). An outfile is optional.
Using WRKLNK and option 8 (Display attributes), you can see the
'Need to archive (System)' information for an IFS object. It is
changed to 'Yes' when the object is saved with a SAV command
specifying UPDHST(*YES). CHKIFSSAV allows a review of the objects
needed to be saved.
- CHKMLTMBR
The Check Multiple Members command checks one or more files to
determine those that have more than one member and those that allow
more than one, but have 0 or 1 members. Exceptions are displayed or
listed. Source files are implicitly bypassed. Only data base data
files that can have members are checked (DDM is excluded).
- CLRMSGQ2
The Clear Message Queue 2 command allows you to clear messages from
one or more message queues based on the number of hours a message
has been on the queue. CLRMSGQ2 may be used for any system message
queue such as QSYSOPR or QSYSMSG or any user message queue. The
command defaults to ACTION(*CHECK) to provide an indication of what
would happen if ACTION(*REMOVE) had been specified.
- CPYDBFDTAQ
The Copy Data Base File to Data Queue command copies a member of a
data base file to a data queue. The data queue must be non-keyed and
have a length less than or equal to 5000 bytes. The QSNDDTAQ API is
used.
- CPYDTAQ
The Copy Data Queue command copies the entries from one data queue
to another. Both non-keyed and keyed data queues are supported, but
must be of the same type, must have the same key length, and the
same sender ID attribute. The entries may be added to or replace the
entries in the To data queue. The QSNDDTAQ API is used.
- CPYNEWSRCM
The Copy New Source Member command copies new members from one
source file to another. A specific member, a generic member, or all
members may be specified. If the member in the From file does not
exist in the To file, it is copied to the To file. If it exists, it
is flagged. A listing always occurs.
- CPYSPCDBF
The Copy User Space to Data Base File command copies data from a
user space to a data base file. The data base file may be up to 9999
bytes in length. An optional parameter allows copying of less than
the full space. If the last data in the space is not the full length
of a record, blanks will be appended.
- DLTLIB3
The Delete Library 3 command provides a simple front end to DLTLIB
and cleans up the low level messages. When the system DLTLIB command
is used, low level messages are sent for each object that is
deleted. DLTLIB3 cleans up the messages if the library is
successfully deleted. If an error occurs, all messages will still
exist.
- DLTOWNOBJ
The Delete Owned Objects command allows an *ALLOBJ user to delete
the objects that are owned by another profile. The command defaults
to ACTION(*CHECK) to allow a review of the objects that would be
deleted.
- DSPAPYPTF
The Display Applied PTFs command displays objects that have a PTF
number applied. One, generic, or all objects by type may be
displayed in one or more libraries.
- DSPDUPPRFA
The Display Duplicate Profile Attributes command displays or lists
the profiles that have duplicates for such attributes as Initial
Program, Job Description, User Class, etc. This provides a review of
where changes may be needed.
- DSPLSTPWDC
The Display Last Password Change command lists all or generic
profiles by the date the password was last changed. Profiles that
are set to PASSWORD(*NONE) are bypassed. The default is for
ascending sequence.
- DSPMSGCNT
The Display Message Count command displays a list of message queues
and the number of messages in each. By default, message queues
without any messages are bypassed.
- MOVCRTDAT
The Move by Create Date command moves objects from one library to
another based on a range of object creation dates specified. Because
ACTION(*CHECK) is the default, no objects are moved and a listing
describes those that would be moved. If ACTION(*MOVE) is specified,
the objects are moved.
- MOVMSGD
The Move Message Description command moves one, a range, or all
message descriptions from one message file to another. Any message
IDs that are moved are removed from the From message file. A listing
is displayed or output of all messages moved and any errors that
have occurred.
Enhancements
- CHKFLDSPE
A new parameter has been added to allow an escape message to occur
if spelling errors are found.
- CVTDTAQ
A new field has been added to the outfile for entry number. The
TAADTQMP is now a keyed file by entry number. The TAADTQML logical
file has been added.
- CVTFRMHEX
Optional parameters have been added for an error location if an
invalid hex value exists and the value in error.
- DSPDTAQ
The largest entry size that may be displayed has been increased to
5000.
- MAILADR
A new parameter has been added to RTVMAILADR to allow the name that
is specified to be treated as a generic name. The name parameter is
now specified as *CHAR instead of *NAME thus allowing any value to
be entered as a name.
- PRTLIBCNT
New parameters have been added for OMITLIB and LIBTYPE.
- SNDDTAQ
The maximum entry length has been increased from 512 to 5000 which
is the largest value allowed in command definition. An additional
parameter has been added to RCVDTAQ to allow up to 5000 bytes to be
returned.
- SRCARC
A new command CHKSRCARC has been added to list whether the archive
members have an existing member in a source file.
- TIMRCD
The maximum number of days difference has been increased from one to
five.
- WRKALLSPLF
The selection by USRDTA (if not generic) now uses the API selection
to improve performance.
Fixes
- AUDLOG
The PRTAUDLOG tool failed with SEQ(*CODESUB) because an invalid
field name was used on OPNQRYF. This has been corrected.
- CAPSECINF
The RFMSECINF command failed with a text description that exceeded
50 bytes. This has been corrected.
- CHGOBJAUT
The internally used PRINT command used *OPN instead of *OP2 which
caused a spooled file to get printed on a very fast system.
CHGOBJAUT is used by several commands that create outfiles. This has
been corrected.
- CMPLIBOBJA
A system error existed in the description of the OADDAT field in the
DSPOBJAUT outfile. This caused the date to be handled as *MDY
instead of *JOB. The TAA function has been created.
- CVTIFSAUT2
The IAOWNR field was not being filled and the user profile name was
not being checked. This has been corrected.
- CVTMBRD
The internals have been reworked to use CVTOBJD6 instead of
RTVOBJLST which was causing errors in some cases with DSPDLTSPC. The
file parameter was not being handled correctly.
- CVTOUTQ
Some changes have occurred in handling of errors reported by the API
used. The same change has been made to CVTWRKSPLF.
- DSPDSKSTS
If the DSASP2 number from CVTDSKSTS was 0, the command failed. The
disk units are now described as 'Not added'.
- PAUSE
The number of seconds was missing from line 24 for the the default
message. This has been corrected.
- PRTASPLIB
When a change from an ASPDEV to an ASP number occurred, the value
shown overlaid the previous value.. This has been corrected.
- PRTNONOBS
The command failed if the storage was freed for a program. This has
been corrected.
- RTVCMDSRC2
If the display and printing of the help text is not complete, the
code attempts to continue.
- RTVJOBSTS
When STATUS(*LASTDATE) was specified, the wrong status could be
returned. This has been corrected.
- RTVOBJLST
The size of internal fields has been increased to account for a
library with many objects.
- SYSACT
In some environments, the CAPSYSACT command failed because of a
mismatch of the QAITMON file and the file in the created library.
The FMTOPT parameter has been added to the CPYF command to account
for this.
Incompatibilities
- CHKFLDSPE
The TAAPRT1 printer file is now used instead of QPRINT.
2013-01-15 (R56)
New
- ACTDLTRCD
The Activate Deleted Record command writes an initialized record to
a physical file relative record number. The record must be in a
deleted status. This makes an active record in the file that can
then be updated by other functions. The companion command is
DLTACTRCD which deletes an active record.
- ADDGRPPRF
The Add Group Profile command adds a Group Profile to one or more
user profiles. The Group Profile is added either as the GRPPRF
parameter or as a supplemental group (SUPGRPPRF parameter). A
listing is output of the changes and any error conditions such as
the profile is already specified as belonging to the group.
- ADDINZRCD
The Add Initialized Record command adds one or more initialized
records to an existing member of a physical file. Initialized
records will have valid values in decimal fields, date fields, etc.
- CHGPRFPUB
The Change User Profile to *PUBLIC command is designed for the
situation where the objects in a library for the *PUBLIC user have
different forms of authority and you want to authorize a new user
profile to have the same authority as the *PUBLIC user. This would
allow you to make the new user profile a group profile for
designated profiles and then set the *PUBLIC user to *EXCLUDE to
prevent access by non-authorized users. This allows members of the
group to have the same authority as they had before.
- CHGPRFPUB2
The Change User Profile to *PUBLIC 2 command is designed for the
situation where IFS objects in a directory for the *PUBLIC user have
different forms of authority and you want to authorize a new user
profile to have the same authority as the *PUBLIC user. This would
allow you to make the new user profile a group profile for
designated profiles and then set the *PUBLIC user to *EXCLUDE to
prevent access by non-authorized users. This allows members of the
group to have the same authority as they had before.
- CLCLRGVAR
The Calculate Large Variable command allows CL to work with
character variables that exceed 15 bytes in length and contain up to
30 digits. Simple operations of Add, Sub, Multiply, and Divide are
supported. Any values placed in the Factors are right aligned. The
return result must be specified as *CHAR LEN(30) and will be right
adjusted by default with leading blanks. A return value exists for a
minus sign.
- CMPDAT2
The Compare Date 2 command provides a simple comparison of a
specified date to the current date plus or minus a number of days. A
return variable that will contain GE or LT must be specified. The
command is very efficient if the dates to be compared are in the
current year. CMPDAT2 provides a simple method of determining
whether a date is in a range of days from the current date.
- CRTALLPRX
The Create All Proxy command checks for or re-creates commands as a
proxy type that have the same name as a command in either QSYS or
TAATOOL. Normal user commands are bypassed. Using proxy commands is
safer for growth and should be used rather than duplicating a
command object.
- CRTINZRCD
The Create Initialized Record command creates one initialized record
from an existing file into a new file. When using the DFT DDS
keyword on many physical file fields, you may want to ensure the
defaults are set correctly. CRTINZRCD creates an all default record
to allow a review. The PRTDB2 command can be helpful in reviewing
the values in the new file.
- CVTIFSDAUT
The Convert IFS Data Authority command converts the output of the
RTVIFSEAUT or CVTIFSEAUT commands individual fields to the
description for data authorities that is seen using WRKLNK (option 9
for Work with Authorities). For example, if Read and Execute are the
only individual data authorities that are specified, *RX would be
returned.
- CVTOBJAUT
The Convert Object Authority command creates an outfile of
authorities for one or more objects in a library. The model file is
QAOBJAUT (same as used by DSPOBJAUT). The outfile is always OBJAUTP
with a format name of QSYDSAUT. The system command DSPOBJAUT allows
output for a single object.
- DSPFMTSEQ
The Display Format Sequence command displays the fields in a
physical or single format logical file in various sequences such as
by field name or type and length. When a file has a large number of
fields, DSPFMTSEQ may be helpful in reviewing the fields in the
format.
- DSPOBJDMG
The Display Object Damage command displays object damage as reported
by the object list API (QGYOLOBJ). This may not be the only damage
to an object. If damage is reported, you should re-create any such
objects.
- DSPTRGSTS
The Display Trigger Status command displays the trigger status of
the programs for one or more files in one or more libraries. An
'escape' parameter exists to allow you to send an escape message if
one or more programs are disabled or inoperative.
- EXPFIL
The Expire File tool is a series of commands that allow you to set
an expiration date for a file of any type. The system supports an
expiration date for members, but not for files. You must have
*ALLOBJ authority to use any of the commands in the EXPFIL tool.
- RTVMSGD3
The Retrieve Message Description 3 command retrieves the format of
the replacement data descriptions for a specific message ID. A large
variable is returned made up of 20 byte elements for up to 49
replacement descriptions. Each element contains the type, the
length, and the number of decimal positions if any. The QMHRTVM API
is used.
- SCNDBFFLD2
The Scan Data Base Field 2 command is intended for name and address
data base files when some pieces of a name and address are known but
not all. SCNDBFFLD2 scans up to 5 character fields for up to 5 15
byte strings each. For example, if you know a string of letters from
a name and a few from the address, SCNDBFFLD2 can help find the
record.
- TRGSAMPLE
The Trigger Sample tool provides some sample objects for learning
how to write a trigger program. Starting with a sample that uses
standard field names for basic trigger fields and your own field
names for your data base file makes it simple to write a trigger
program. You must copy the code from the TAA Archive to be able to
work with it.
- UPDPFILE2
The Update PFILE 2 command updates one or more LF source type (not
LF38) members to change the PFILE keyword to a library qualified
value. This allows the source to be changed to indicate that the LF
should be built over a PF in a specific library. If the existing
physical file is on the library list, attempting to create the new
logical file over a copy of the physical can often result in the
logical being built over the wrong physical file.
- WRKOWNOBJ
The Work Owned Objects command provides a work display for a user
profile's owned objects. The outfile from DSPUSRPRF TYPE(*OBJOWN) is
used internally to provide the basic information. Various options
exist to work with the objects such as change, delete, display,
duplicate, etc.
Enhancements
- CRTDBFJRN
A new parameter has been added for GENLVL.
- CVTLIBCNT
A new field has been added to the outfiles for the library ASP
device name.
- DYNMNU
Two new commands MTNMNUHST and MTNMNUCMD have been added to assist
in the cleanup of the MNUHSTP and MNUCMDP files. Both commands allow
a retention date.
- JOBACG
The ANZJOBACG command now supports selection on the number of CPU
seconds used.
- PRTLIBANL
The ASP parameter now supports 1-99. The ASPDEV parameter has been
added.
- PRTLIBCNT
A new option exists to sequence on the ASP device name. The ASP
device name now appears on the listing.
- SNDUSRBRK
A new parameter has been added to allow control over whether the
user receives a message at each signed on workstation or only the
first.
Fixes
- CPYSPLFIFS
The objects in QTEMP are now cleaned up. A restriction is now stated
relative to the owner or whether *ALLOBJ is required. The program
was not monitoring for an IFS object not found. This has been
corrected.
- CVTAUDLOG3
The command has been updated to use the *TYPE5 journal entries now
used by the AUDLOG tool.
- CVTOBJD3
The use of DSPOBJD to the outfile TAATMPOBJ did not create a *NOMAX
size file. This has been corrected.
- RTVPFSRC
The CCSID keyword was added if the field type of date, time, or
timestamp. This is invalid and the keyword is now dropped. Also
caused error with CRTDBFJRN.
Incompatibilities
- CVTDTAQ
The TAADTQMP file is now a keyed file by entry number.
2012-10-15 (R55)
New
- CLRJOBQ2
The Clear Job Queue 2 command clears selected jobs from a job queue.
Jobs may be cleared based on a combination of selection criteria
such as job, user, status, and priority. At least one selection type
must be made. A job must satisfy all selection types specified to be
ended. A 'check option' exists to allow a determination of which
jobs would be ended.
- CLROUTQ3
The Clear Output Queue 3 command clears selected spooled files from
an output queue. Spooled files may be deleted based on a combination
of selection criteria such as job, user, form type, status, and
priority. At least one selection type must be made. A spooled file
must satisfy all selection types specified to be deleted. A 'check
option' exists to allow a determination of which spooled files would
be deleted.
- CPYMSG
The Copy Message command copies one or more messages with a specific
message ID from one external message queue to another. The message
is copied to the To queue by the use of SNDPGMMSG. A selection by
job, user, and job number may also be made.
- CPYPGMQM
The Copy Program Message Queue Message command copies one or more
messages from the current job's program message queue to an external
message queue. You must use RTVMSGKEY to mark the boundary of where
messages should begin to be sent from. CPYPGMQM may be used in
special debugging situations or on a normal basis to capture problem
determination information instead of the entire job log.
- CVTJRNRCVD
The Convert Journal Receiver Directory command creates an outfile
with one record per journal receiver for a specific journal. The API
QjoRetrieveJournalInformation is used. The outfile is always JRNFILP
with a format name of JRNRCVR. This is the same outfile as was used
by CVTJRNA.
- CVTOBJD6
The Convert Object Description 6 command creates the OBJDSCQ outfile
of objects similar to DSPOBJD. However, the output records contain
only the object, library, object type, object attribute, user
attribute, and text description. The advantage of this approach is
that the system does not have to determine the size of the objects.
If a file has many members, the basic information can be retrieved
quickly.
- DSPEMTAUTL
The Display Empty Authorization List command displays Authorization
Lists (not owned by QSYS) that do not control any objects. This
includes library objects, IFS objects, and DLS objects. An option
exists to include all Authorization Lists (not owned by QSYS).
- DSPEMTMSGF
The Display Empty Message File command displays one or more message
files that have no message IDs. A flag may be set if the message
file has not been used in the last n days. An option exists to list
all message files. DSPEMTMSGF can be helpful in cleaning up unused
message files.
- DSPEMTSAVF
The Display Empty Save File command displays or lists one or more
save files that have no objects. The default is to bypass save file
names beginning with Q as there may be many PTF save files in
existence.
- DSPEMTSPC
The Display Empty User Space command displays or lists one or more
User Space objects where the User Space contains only the initial
value described when CRTUSRSPC was used. An option exists to list
all User Space objects. DSPEMTSPC can be helpful in cleaning up
unused User Space objects.
- DSPIPLHST
The Display IPL History command displays or lists the dates and
times that an IPL has occurred within a range of dates. The
inclusion of the normal power down entries is optional as well as
IPL completion. You must be using the CVTQHST2 tool command to first
convert the QHST information.
- DSPOBJ2
The Display Object 2 command provides a subfile display of one or
more objects. The display format is similar to WRKOBJ, but supports
only a single option 5=Display. This invokes the TAA DSPOBJD2
command which provides other display options such as DSPOBJAUT and
the F8 option which changes based on the object type to allow a
display of additional details.
- DSPPTFSAVF
The Display PTF Save File Summary command provides a summary of save
files for each release and product ID combination. This allows a
review of how much space is being taken by PTF save files in QGPL.
- DSPWTR
The Display Writer command is similar to the system WRKWTR command,
but allows only display options plus describing the number of files
in the associated output queue. The command is intended for end
users who need to display information about one or more writers, but
should not be able to make any changes. An optional method of
displaying the output queue associated with the printer is provided.
- DSPWTRSTS
The Display Writer Status command displays the status of a writer.
The printer device name must be entered. No change options are
supported. This allows typical end users to determine the writer
status without providing options to change.
- DUPCHAR
The Duplicate Characters command duplicates a string of 1 to 50
characters to a return variable. An output length must be described.
The return variable must be 32,000 bytes. DUPCHAR can be used as a
testing aid or for other unique situations.
- EDTLRGVAR
The Edit Large Variable command provides editing for a large
character variable that contains numeric data. Some system functions
return large character variables that exceed 15 digits and place
them in *CHAR variables. A *CHAR input value of up to 30 bytes is
supported. The return CHROUT value must be declared as *CHAR
LEN(43).
- SCNQHST
The Scan QHST command scans QHST information for a string of
characters. You must first convert the QHST information using the
CVTQHST2 command of the DSPQHST2 tool. Selection of which messages
to scan may be made on a date range, Job, User, Job number, and
Message ID. The scan occurs on the first level text and the message
data of the each message.
- WRKJOBQ2
The Work Job Queue 2 command is similar to the system WRKJOBQ
command, but allows all or a generic named job queue in a named or
generic library. Similar options exist as with WRKJOBQ to work with,
hold, release, etc. If you have multiple job queues in the same
library, WRKJOBQ2 can be helpful in reviewing the jobs.
- WRKROMNUM
The Work Roman Numeral tool provides 3 commands. CVTFRMROM converts
from a Roman Numeral such as LX to a decimal value. CVTTOROM
converts from a decimal value to a Roman Numeral value. WRKROMNUM
provides a work display with both functions.
Enhancements
- AUDLOG
The new RFMAUDLOG command may be used to increase the size of the
entry data field.
- CVTJOB
A new field has been added to the outfile for active job status.
- CVTJRNA
The JRNRCVP file is now output by the CVTJRNRCVD command.
- CVTMODINF
A new field has been added to the outfile for Close SQL cursors.
- DSPSBMJOB
A new parameter has been added to allow a constant to be used
instead of the program name when SPLF(*PGM) is specified.
- JOBACG
A new command RTVJOBACGR (Retrieve Job Accounting Record) has been
added.
- MTNJRN
If a single journal is specified, the MTNJRN data area will be
created in QTEMP with information regarding the receiver that was
created (if any), the number of deleted receivers, and the amount of
deleted storage.
- RGZALLPFM
New parameters have been added to better match the RGZPFM system
command.
- RGZLIB
A new parameter has been added to allow bypassing of files that are
being journaled.
- RTVILEMODA
A new parameter has been added for CLSSQLCURS.
- SBMJOBSCDE
A new parameter for USRPRF has been added to allow either the name
in the job schedule entry or a specific user profile. You must be
authorized to the profile to be used.
- SCNVAR2
The size of the PATTERN has been increased from 999 to 5000.
- SPLARC
A new command (DSPSPLARCS) has been added to provide different types
of summaries of the spool audit records.
Fixes
- AUDLOG
The AUDLOGP file now supports 20 byte journal entry sequence
numbers. The RFMAUDLOG command has been added and is required to
reformat the existing files. Longer entry data characters were being
dropped. This has been corrected.
- CHG128PWD
The CHG128PWD command had the wrong library qualifier for the
TAASEKKC9 program. It should be TAASECURE. The TAASEKKC program
attempted to run CHG128PWD2 from TAATOOL2 instead of TAATOOL. These
errors have been corrected.
- CHKIBMLIB
User libraries were not being properly considered when LIB(*ALLUSR)
was specified. This has been corrected. Other tools such as
CHKALLDBD and CVTLIBDBF were impacted.
- CLPDBR
The TAADBKNR51 program did not specify a return which caused the
compilation to fail with the latest PTF. This has been corrected.
- CMPSYSVAL
Additional entries for QAUDCTL are now being compared. Additional
entries for QSSLCSL are now being converted. This applies to V6R1
and following IBM i releases.
- CPYSPLFIFS
The command requires less authority t use. This is due to the
CHKPRDOPT system command being checked by a program that adopts and
the use of RTVIFSED which no longer requires authority to the
TAACVTIFS Authorization List.
- CVTAUTLOBJ
In some cases, the same objects were output twice. This has been
corrected.
- CVTCMDA
If the command information cannot be retrieved using the sub tool
RTVCMDA, the value '**RTVERR**' is placed in the CACPP field. If a
CPF6250 retrieve error occurs, CVTCMDA no longer ends with an escape
message.
- CVTJRNA
The writing of the JRNRCVP file is now done via the new tool
CVTJRNRCVD. This allows greater than 1500 journal receivers to be
converted. LF38 file types were not being handled. This has been
corrected.
- CVTLIBDBF
The proper format is now checked for and a specific error message is
used to describe how to recover if differences exist.
- CVTPGMA
Escape message CPF9806 (cannot perform operation) are now bypassed.
A similar change has been made to CVTPGMA2 and CVTMODINF.
- CVTPING
Message TCP3206 (no response in n seconds) is now being checked
further. This avoids zeros in many fields in the outfile.
- CVTPRTSTS
If a specific printer devices was named, all devices were output.
The device description was blank in the outfile. These errors have
been corrected.
- CVTSAVFD
The TAASPACE *USRSPC object was not being created. This has been
corrected.
- CVTSYSVAL
Only the first entry for QAUDCTL was being converted. The multiple
entries for QSSLCSL were not being converted. These errors have been
corrected. This applies to V6R1 and following IBM i releases.
- CVTWRKSPLF
The EXPDATE(*NONE) value did not convert any spooled files that had
blanks in the expiration date field. This has been corrected.
- DSPACGSGN
The user profile name was blank on the listing. This has been
corrected.
- DSPOBJD2
A generic library name was not properly handled. Libraries that did
not match were included. This has been corrected. Better handling of
errors from sub functions has been included along with a better
error message if a single object request failed.
- DSPSBMJOB
If F5 was used to refresh, the command aborted in some cases because
the user space did not exist. The size of the internal array has
been increased from 1000 to 2000 jobs.
- DSPWHRUSE
The CRTWHRUSE command was failing if QUERY(*YES) was specified and
no query objects existed. This has been corrected.
- HLDJOB2
The command did not find jobs on the job queue. This has been
corrected. The interface has been reworked so the JOBTYP parameter
is now JOBSTS.
- JOBACG
The RFMJOBACG command failed if converting from V5R4 to V7R1 because
a logical file did not exist. This has been corrected.
- QRYUSE
The CRTQRYUSE command was failing on some attempts to access the
outfile of objects.
- RLSJOB2
The command did not find jobs on the job queue. This has been
corrected. The interface has been reworked so the JOBTYP parameter
is now JOBSTS.
- RTVIFSED
The command (and RTVIFSED2) no longer checks for authorization to
the TAACVTIFS authorization list.
- RTVSAVFD
The TAASPACE *USRSPC object is deleted in QTEMP when the command
completes.
- SAVCHG23
The command was failing on SAVSECDTA. This has been corrected.
- SCNDUPRCD
The command failed in some cases if a large number of duplicate
groups were found. More than 9999 are now bypassed.
- SCNSPLF
The size of the internal file in QTEMP has been set to *NOMAX.
- SCNSPLF2
The size of the temporary file in QTEMP has been changed to *NOMAX.
- SNDESCMSG3
The command failed if used in batch. Instead of creating a message
queue in QTEMP, the existing TAAMSGF message file is used to correct
the problem of QTEMP being cleared by the system at job end. The
same change has been made to SNDPGMMSG2.
- SNDSPLPDF
Less authority is now required. See the changes for the sub tool
CPYSPLFIFS.
- SNDTXTMAIL
When logging was used with multiple send-to's, the recipient type
was set to blanks causing a failure. This has been corrected.
- STRJRNLIB2
CVTOBJD4 is now used instead of DSPOBJD to create outfiles. This fix
was not put into V5R4 and previous releases.
Incompatibilities
- AUDLOG
The AUDLOGP file now supports 20 byte journal entry sequence
numbers. The RFMAUDLOG command has been added and is required to
reformat the existing files.
- CVTCMDA
If a command cannot be retrieved using the sub tool RTVCMDA, the
value '**RTVERR**' is placed in the CACPP field. If a CPF6250
retrieve error occurs, the command now completes normally.
- HLDJOB2
The command interface has changed. The JOBTYP parameter is now
JOBSTS.
- RLSJOB2
The command interface has changed. The JOBTYP parameter is now
JOBSTS.
- RTVIFSED
Authorization to the RTVIFSED command (and RTVIFSED2) is now
*PUBLIC. Prior to this, a check occurred in the CPP to ensure *USE
authority to the TAACVTIFS *AUTL.
2012-07-15 (R54)
New
- ADDHEX
The Add Hexadecimal command adds or subtracts two hexadecimal or
decimal values and returns either or both a hexadecimal or decimal
value. Either unsigned or signed hex values may be entered. ADDHEX
can be helpful when viewing dumps or user spaces.
- CHGDTAQD
The Change Data Queue Description command changes one or more
attributes for a data queue. Only standard data queues are supported
(not DDM data queues). The API QMHQCDQ is used. Not all attributes
are supported by the API.
- CHGFUNCNAM
The Change Function Name command allows you to change the
description of the Function field on WRKACTJOB to provide a better
indication of what a job is doing. The command must be used in a CL
program and not from a command entry line. The value on WRKACTJOB
would appear as USR-xxxx where xxxx is the 10 bytes specified on
CHGFUNCNAM.
- CHKCCSID
The Check CCSID command checks one, generic, or all objects in a
library for a specified CCSID. An escape message (TAA9891) is sent
if any exceptions exist and a listing is displayed. Only the object
types that support a CCSID are checked.
- CHKDEC
The Check Decimal command checks a string of up to 512 bytes for
whether only digits 0-9 exist. Embedded blanks are considered
invalid. A check for a leading and trailing minus sign is optional.
- CHKJOBSTS
The Check Job Status command provides a simple test to determine if
a job exists and what the status is (such as *JOBQ, *ACTIVE, or
*OUTQ). A job type such as INT or BCH may also be specified. An
exception message is optional if more than one job meets the
criteria.
- CHK1STMBR
The Check 1st Member command checks one or more files to determine
if the first member has the same name as the file. Exceptions are
displayed or listed. Source files are implicitly bypassed. Only data
base data files that can have members are checked (DDM is excluded).
- CLRGENSRC
The Clear Generic Source command clears generic members in one or
more source files in a specified library. Special values such as
*STD may be used for the source file name to clear generic members
from source files such as QCLSRC and QCMDSRC. The default is
ACTION(*CHECK) which describes in messages the members that would be
cleared.
- CVTJRNOBJ
The Convert Journal Objects command converts the objects that are
being journaled from a specified journal to an outfile. Different
object types are handled including IFS objects. The outfile is
always CVTJRNP which uses the model file TAAJROTP and a format name
of JRNOBJR.
- DLTGENPRF
The Delete Generic Profile command deletes profiles using a generic
user profile name. User profiles starting with the letter 'Q' or
owned by the system cannot be deleted. The default is ACTION(*CHECK)
which does not delete any profiles.
- DLTLSTUSE
The Delete Last Used command deletes objects in a library based on
the last used date and the number of days specified. If an object
has never been used, the create date is used instead. DLTLSTUSE
provides a cleanup when objects are no longer being used.
- DSPEMTLIB
The Display Empty Libraries command displays or lists one or more
libraries that have no objects. The command performs quickly as the
simplest form of the API to retrieve object information is used.
- DSPJRNOBJC
The Display Journal Object Counts command displays or lists counts
of object types that are being journaled to a named journal. This
includes data base files, members, access paths, data areas, data
queues, IFS objects, command definitions, libraries, and journal
receivers.
- DSPNETSVRA
The Display NetServer Attributes command displays or lists the
attributes associated with the i5/OS NetServer. This includes both
the current and pending attributes.
- DSPNETSVRS
The Display Net Server Statistics command displays the current i5/OS
NetServer statistics. The RTVNETSVRS command is used internally
which runs the QZLSOLST API.
- RTVCCSIDPF
The Retrieve CCSID From PF command retrieves the CCSID from a
physical file. If the file has multiple CCSIDs, TAA9896 is sent as
an escape message.
- RTVJRNOBJC
The Retrieve Journal Object Counts command retrieves summary
information for different object types that are being journaled to a
named journal. The API QjoRetrieveJournalInformation is used. The
counts are kept by the system (the individual object information is
not read).
- RTVNETSVRA
The Retrieve NetServer Attributes command retrieves attributes about
the NetServer. Both current and pending attributes may be retrieved.
- RTVNETSVRS
The Retrieve NetServer Statistics command retrieves the current
statistics about the NetServer such as the number of file opens and
the average response time. The QZLSOLST API is used.
- WRKADDHEX
The Work Add Hexadecimal command provides a work display for adding
a hex or a decimal value to a hex or decimal value. The hexadecimal
values may be entered as either unsigned or signed values. The
result is returned as both hex and decimal values. Help text is
provided for the display.
Enhancements
- CAPSECINF
A new command (RFMSECINF) has been added to reformat the files used
if a level ID change occurs because a new version was installed.
- CHKRSDSTE
A new parameter has been added to allow an update of the date/time
the command found that the restricted state was reached.
- CPYTOCSV
The maximum field size has been increased to 2000 bytes both before
running and placing of quotes into the output data.
- CRTDBFJRN
A RCVRNG parameter has been added to allow additional control of
what journal entries should be retrieved.
- CVTJRNA
A MBROPT parameter has been added to allow adding records to the
outfile members.
- CVTLIBLCK
An OBJ and OBJTYPE parameters have been added to the command.
- CVTOBJD3
A generic library name is now supported.
- CVTOBJD4
A generic library name is now supported.
- DLTIFS
A new keyword DLTSYMLNK has been added to DLTIFS/DLTIFS2 to prevent
the deletion of *SYMLNK object types. The default remains the same
to delete them.
- DLTOLDQRPL
The number of hours has been increased from 99 to 999.
- DSAUSRPRF
A new file exists in TAASECURE that can be used to add exception
profile names that cannot be disabled. This provides additional
names over the 45 supported by the constant data area in TAASECURE.
- DSPAUTLOB2
A summary by object type is now provided.
- DSPDTAQD
New fields have been added for Auto Reclaim and Enforce Locks.
- FAVCMD
A REPLACE parameter has been added to the ADDFAVCMD command. A new
command EXCFAVCMDL has been added to allow combining existing IDs to
execute them consecutively. ADDFAVCMD may also be used after
EXCFAVCMDL to assign a new ID for the combined set.
- OUTFFLD
A new command SCNOUTFFLD has been added to allow scanning for a
string of text in the field description text.
- RCVMSGKEY
An new return variable has been added for the RTNMSGID.
- RPTCMD
The command to be entered may now be prompted with F4.
- RTVDSPFA
An new return variable has been added for the CCSID of the file.
- RTVPRTFA
An new return variable has been added for the CCSID of the file.
Fixes
- Install
The SECMSG *MSGF was not getting installed. This has been corrected.
The install program TAINSBC5 was affected.
- CHGOBJAUT2
If the library was controlled by an *AUTL and the CRTAUT value was
the name of an *AUTL (could be the same), the command failed. This
has been corrected and the object being changed is now controlled by
the *AUTL and the *PUBLIC profile set to *AUTL. This was causing a
failure for the tools that created outfiles in this type of library
such as CVTCLSA.
- CMPWLDCRD
When CMPWLDCRD or CMPWLDCRD2 was used and part of the name was
satisfied, but not all, the compare value was not reset. This has
been corrected.
- CRTDBFJRN
If INZDLTDFT(*YES) is used on a file with IMAGES(*AFTER), the tool
now sends an escape message if the user does not have *OBJOPR and
*OBJMGT. Prior to this change, the tool failed on CRTDUPOBJ. The
CRTDUPOBJ command has been changed to specify CST(*NO) and TRG(*NO).
- CVTAUTLOBJ
When used with a large number of objects, the command sometimes
failed. This has been corrected.
- CVTDSKSTS
In some cases, there was no TAASYSFC member which is now added. This
has been corrected.
- CVTJRNA
If a journal receiver was deleted during processing, the command may
fail. A check is now made, and if a receiver no longer exists, it is
bypassed.
- CVTMSGF
The change made in Jan, 2011 for V5R4 was in error. This has been
corrected.
- CVTOBJD3
The OUTMBR parameter was not being processed. This has been
corrected.
- DSPAUTLOB2
The objects count information was wrong in some cases. This has been
corrected.
- DSPIFS
When a non-generic name was used in the OBJNAM parameter, all
objects were being displayed. When searching for asterisks in the
OBJNAM parameter, in some situations excess *ANDs were inserted in
the selection. These errors have been corrected.
- DSPSBMJOB
The sequencing of the display is now done by both date and time the
job entered the system.
- FNDCMD
In some cases the CRTFNDCMD found commands that identify themselves
as PRX, but the RTVCMDA command failed on an unknown library. This
error is now bypassed.
- JOBACG
If option 6 was used on DSPJOBACG, the prompt for the Audit Log
library now allows an overkey by the user.
- MTNJRN
If a journal receiver was deleted by another job during processing,
the command could fail. This condition is now bypassed.
- PRTAUTLOBJ
If an *AUTL was locked, the information could not be accessed and
the command failed. This condition is now bypassed and noted in the
output. PRTAUTLOBJ failed if an object was deleted during
processing. This condition is now just bypassed. PRTAUTLOBJ also
failed if an object was locked. This condition is now noted on the
listing.
- RCVMSGKEY
The command now includes the ENDKEY parameter which must be filled
from the RTVMSGKEY command which should be issued after the function
that cause low level messages.
- RMVOLDMSG
The command mostly failed with no messages found as of an early 2012
version. This has been corrected.
- SBMSAVSNDL
If a specific JOBQ was named, an error occurred on CHKOBJ3. This has
been corrected.
- SNDUSRBRK
If a user had multiple jobs and a request for the user was made, not
all jobs were sent to. This has been corrected.
- WRKIFS
The selection criteria was not handled properly when lower case was
used in all situations. This has been corrected.
Incompatibilities
- RCVMSGKEY
The ENDKEY parameter has been added and is required. It should be
filled with the value from RTVMSGKEY that should be entered before
the function that creates low level messages.
2012-04-15 (R53)
New
- ADJTIM
The Adjust Time command adjusts the time of day clock. The
adjustment is specified either plus or minus in microseconds. The
adjustment period occurs over a period of time such as it may take
several minutes for a few seconds to be adjusted. The time for the
adjustment to take place is also dependent on hardware speed. The
QWCADJTM API is used.
- ANZCLPCMD
The Analyze CLP Commands command analyzes the CLP commands in the
CLPCMDP file created by the CVTCLPCMD TAA tool. A summary by command
name is listed. Selection can occur by such things as a source file
name and library.
- CHKLVLMSG
The Check Low Level Message command allows you to monitor for a
message ID sent by a command that does not send an escape message.
The message being sent must be from a message file (it cannot be an
'impromptu' type). See the example in the tool documentation for how
to use CHKLVLMSG.
- CMPDBF3
The Compare Data Base File 3 command compares a member from two data
physical files. The files are copied to temporary files in QTEMP and
a logical file is built over each file with the key as the entire
record. The From file is then read and an attempt is made to to
randomly access the same key in the To file. Exceptions are noted.
The process then repeats for the To file.
- CPYFRMSTM2
The Copy From Stream File 2 command is a front end to the system
CPYFRMSTMF command. CPYFRMSTM2 uses a normal object prompt for a
file and member to allow a simple copy from an IFS stream file to a
data base member or save file. Only a member of a program described
physical file, a member of a source physical file, or a save file
may be copied to.
- CPYSPLF3
The Copy Spooled File 3 command splits a spooled file into multiple
spooled files based on a change in value of the data at a specific
line and position of each page. Assume you have a report by salesman
for all salesmen and want to split the report so there is separate
spooled file for each salesman. The salesman number must be listed
at the same location on each page, but does not have to be on the
first line.
- CPYTOFLAT
The Copy to Flat File command copies an externally described file to
a flat file (a single field file). Decimal and binary fields are
converted to character and an extra position is added for the sign
value for all decimal fields. The flat file must not exist and is
created by the command with a length large enough to hold the data.
CPYTOFLAT can make a human readable data base file.
- CPYTOSTMF2
The Copy To Stream File 2 command is a front end to the system
CPYTOSTMF command. CPYTOSTMF2 uses a normal object prompt for a file
and member. The TOSTMF name defaults to allow a simple copy from a
data base member to an IFS stream file in the user's home directory.
Only a member of a program described physical file, a member of a
source physical file, or a save file may be copied.
- CVTAUTLOBJ
The Convert Authorization List Objects command converts information
about library objects, IFS objects, and or *DLS objects for one or
more Authorization Lists to an outfile. Each object is represented
by one record which includes the full path name. Library objects are
also described with their library names.
- CVTCLPCMD
The Convert CLP Command command converts CL commands from CL type
source to an outfile. One record would be written for each command
with the identifying information such as member name, sequence
number, and last change date. Some commands such as SBMJOB or IF
which contain a sub command will also cause a record to be written
which is identified as a sub command.
- CVTOBJDAT
The Convert Object Description Date command is intended for
converting the MMDDYY format used in the date fields of the DSPOBJD
outfile. The date is returned in the CYYMMDD format. The CPP may be
called directly.
- DSPAUTLOB2
The Display Auth List Objects 2 command differs from the system
DSPAUTLOBJ command by 1) providing *IFS and *DLS objects in addition
to library objects and 2) allowing a generic name or all
Authorization Lists. The full path name (up to 5000 bytes) is
displayed or listed.
- DSPCLPCMD
The Display CLP Command command displays commands from the CLPCMDP
file created by CVTCLPCMD. Various search criteria such as the
source file library may be named. DSPCLPCMD provides a fast access
for where a specific command name has been used.
- DSPDBFFLD
The Display Data Base Field command displays the attribute
information for a field in a physical file or a single format
logical file. The attributes include such things as the length,
decimal positions, buffer position in the record, text, and column
headings.
- DSPLIBAUT
The Display Library Authority command provides a listing of one,
generic, or all objects in a library with the individual
authorizations to objects. One line is output for each authorized
user. Selections can be made by different parameters such as object
type.
- DSPTIMADJ
The Display Time Adjustment command displays the information
regarding a time adjustment. See the TAA command ADJTIM for a method
of changing the time of day clock forward or backward n seconds.
DSPTIMADJ displays the information of whether an adjustment is being
made and if so how much time is needed to complete the adjustment.
The RTVTIMADJ command is also included which uses the QWCRTVTM API.
- RMVEQLSRC
The Remove Equal Source command removes members from a test type of
source file that are a 100% match to a corresponding member in a
production type of source file. The default is ACTION(*CHECK) to
allow you to see what would be removed by ACTION(*REMOVE). RMVEQLSRC
can purge the members that are no longer needed in a test type of
source file.
- SBMFTPCMD
The Submit FTP Command command submits a single command to run on
another System i that is connected via FTP. It could be another LPAR
partition on the same physical hardware. Like SBMNETJOB or
SBMRMTCMD, SBMFTPCMD provides a simple method of submitting a job to
another system, but uses the more popular FTP protocol.
- SNDOBJMAIL
The Save and Mail Object command simplifies sending objects as an
attachment to an Email. The command uses the sub tools SAVOBJIFS and
SNDIFSMAIL to create a save file in QTEMP, save the object(s), copy
the save file to an IFS stream file, and attach the stream file to
an Email which is sent using the SNDDST system command. The TAA Tool
RSTOBJIFS may be used to restore the object(s).
- SNDSPLPDF
The Send Spooled File as a PDF command sends a normal spooled file
as a PDF to one or more users. This allows the end user to view the
information with a technique that he may be more familiar with.
Enhancements
- CMPDBF2
The limit of the number of key fields has been increased from 6 to
10.
- CVTALLJOBQ
A new parameter has been added for ASPDEV.
- CVTALLOUTQ
A new parameter has been added for ASPDEV.
- CVTASPA
A new field has been added for the number of multiple connection
units.
- CVTDSKSTS
New fields have been added to the outfile.
- CVTOBJD4
A new parameter has been added for ASPDEV. The OBJTYPE parameter is
now a list that supports up to 300 object types.
- CVTOUTQ
The QGYSERVER job is now ended when CVTOUTQ completes. The same
change has been made to CVTWRKSPLF.
- CVTWRKSBS
A new parameter exists to allow a specific or generic subsystem to
be named.
- DLTOLDSPLF
The ASPDEV parameter has been added. The LIST parameter now supports
the special value *SYSBAS to allow bypassing of output queues in the
system basic ASP.
- DSPLIBSIZ
The ASPDEV parameter has been added.
- DSPOBJSIZ
A minimum size parameter has been added.
- FNDJOB
New parameters have been added to allow a selection of a start and
end date compared to when the job went active.
- JLGCTL
A new option for the CVTJLGCTL DLTCVTJLG parameter of *YES2 allows
deletion of job logs that are converted by both the current use of
CVTJLGCTL and a prior use that still exist to be deleted.
- RTVASPSTS
The new return parameter exists for the number of multiple
connection units. The new value is displayed with DSPASPA2.
- STRTRCDBG
The command now checks to see if the ILE debugger can be used.
- SYSHST
The total number of spooled file members with data is now displayed.
- TIMRCD
The DSPTIMRCD command now also displays the time difference in
Hours/Minutes/Seconds.
Fixes
- CHKIBMLIB
Some libraries beginning with Q were not bypassed by *ALLUSR.
- CMPSRC
The spooled file name of unmatched members was TAAPRT1. This has
been corrected to be the member name.
- CPYTOCSV
An index error was caused if a large field was to be converted and
the field size increased beyond 500 due to additional quotes and
double quotes. The output size of the output field has been
increased to 600 and a specific error message has been added if this
size is exceeded.
- CVTDSKSTS
Misleading MCH1210 messages have been removed from the job log.
- CVTWRKSBS
An internal variable was defined as a length of 8 instead of 10 for
the subsystem name. This has been corrected.
- DSPDLTSPC
The internal field for deleted space was increased from
- DSPJOBSCDC
If a *MONTHLY job was scheduled for *MONTHEND or *MONTHSTR, the
command failed. This has been corrected. 11/0 to 15/0.
- DSPQHST2
If a specific user was specified along with a message ID to omit,
the code looped. This has been corrected.
- PRTBIGOBJ
A generic name in the OMITLIB parameter failed. This has been
corrected.
- QRYUSE
The CVTQRYUSE command was not converting all files used in some
queries. The support is now better, but may never be perfect.
- RTVNBRACT
The request for a specific subsystem failed if the user was not
authorized to all subsystems. This has been corrected.
- RTVPFSRC
The CCSID keyword is now handled with the *CONVERT and *NORMALIZE
options. The DDS field length for G (Graphic) field type is now
correct. This change improves the CRTDBFJRN capability.
- SNDSTSCNT
The code now ensues that a TOTCNT value greater than 0 is specified
for the *PCT or *BAR options.
- SNDTXTMAIL
The code required that a MAILADR library exist when SENDTO(*INT) was
specified. This has been corrected. The same change has been made to
SNDIFSMAIL and SNDSPLMAIL.
- TIMRCD
If a job ran past midnight, the wrong total time was reported. This
has been corrected.
- WRKRMTOUTQ
The text for the output queue was wrong if OUTPUT(*(PRINT) was used.
This has been corrected.
- WRKSBSJOBQ
The previous fix for a missing library did not blank the previous
library name. This has been corrected.
Incompatibilities
- RTVCCSID
TAA9891 is now sent as an escape message if the file being retrieved
is a source file.
2012-01-15 (R52)
New
- ANZOUTQ
The Analyze Output Queue command provides summary information for
various attributes of spooled files in an output queue such as by
form type, by user, by schedule, by open date, etc. For each
category, a count is also supplied. ANZOUTQ provides a good summary
of what exists.
- CHG128PWD
The Change 128 Password command is intended for those environments
using 128 byte passwords where a change to a user password should be
replicated on one or more systems.
- CHKAUDLOGP
The Check AUDLOGP command checks audit entries for valid changes to
the AUDLOG TAA Tool AUDLOGP file. CHKAUDLOGP helps ensure that the
AUDLOGP file is a true representation of the QAUDJRN journal. You
must be using the QAUDJRN journal and the AUDLOG tool.
- CHKJOBACGP
The Check JOBACGP command checks audit entries for valid changes to
the JOBACG TAA Tool JOBACGP file. CHKJOBACGP helps ensure that the
JOBACGP file is a true representation of the QACGJRN journal. You
must be using the QACGJRN journal and have set auditing for the
JOBACGP file.
- CHKMSGID
The Check Message ID command checks if a message ID exists in a
message file. The command completes normally if the message ID
exists and sends TAA9891 as an escape message if it does not.
- CHKTAACRT
The Check TAA Create System command provides a check of all objects
in TAATOOL to determine if they have been created on a TAASYSnn
system. A listing is produced of any exceptions. It is not an error
to create your own version of some TAA function, but CHKTAACRT
provides an auditor with a tool to review if changes from the
shipped version have occurred.
- CMPJOBA
The Compare Job Attributes command compares the attributes of two
jobs. A display or listing is output of any differences found. When
two jobs differ in how they operate, CMPJOBA may be helpful in
identifying why they differ. This tool was introduced in 7.1.
- CMPSPLFA
The Compare Spooled File Attributes command compares many of the
spooled file attributes between two spooled files. A display or
listing is output of any differences found. When two spooled files
differ in how the output occurs, CMPSPLFA may be helpful in
identifying the differences.
- CVTTIMSTM
The Convert Time Stamp command converts a time stamp of 26 bytes to
a return data structure. Individual fields in the data structure
contain the the date and time in various formats such as CYMD,
HHMMSS, the edited date, and the edited time. The CPP (TAATINYC) can
also be called from a HLL program.
- DLTPNDJLG
The Delete Pending Job Log command deletes job log information (not
QPJOBLOG spooled files) where the job log information is in a
'PENDING' status. A 'number of days' pending may be specified to
delete only the job log information that has been pending for n
days. Specific, generic, or all jobs/users may be named. The
QWTRMVJL API is used.
- DSPJOBTYPD
The Display Job Type Description command displays the codes and
descriptions of different job types. Both the three character codes
used on WRKACTJOB and the one character codes used in APIs are
displayed with the corresponding descriptions.
- DSPSPLFINF
The Display Spooled File Information command displays the number of
spooled files for one or all users. DSPSPLFINF uses the RTVSPLFINF
command to retrieve the information which uses the QSPSPLI API.
- FNDSPLF
The Find Spooled File command can assist when you are trying to find
a spooled file, but you are not sure of the name, the job, the form
type, etc. FNDSPLF allows you to identify one, generic, or all
output queues that should be searched for whatever information you
have such as the form type or some string of characters within the
form type. Most of the selection options supported by FNDSPLF allow
this type of searching.
- LUVSEU
The Love SEU command blanks out the text of the EDT0630 message of
QEDTMSG in QPDA that is used to describe the 'modern alternative to
SEU'. If you love SEU, you can blank out the message and prevent
having to see the words over and over again. The message ID changed
is EDT0630.
- RNMGENSRC
The Rename Generic Source command allows a rename of generic members
in one or more source files in a library. A single source file, all
source files, or special values for source file names such as *STD
may be used.
- RTVOBJD4
The Retrieve Object Description 4 command allows you to retrieve the
basic information about the first or only object of a specific name.
The library and object type default to *ALL. A total number of
objects that match the name is returned. If more than one object has
the same name, messages are sent describing the first 30.
- RTVUTC
The Retrieve Universal Time command retrieves the coordinated
universal date and time (UTC). UTC is based on an atomic clock with
leap seconds added at irregular intervals to synchronize with the
earth's rotation. It may be used interchangeably with Greenwich Mean
Time if sub second precision is not required. UTC may be useful when
dealing with data from around the world.
- SECLOG
The Security Log tool is designed to assist in auditing *ALLOBJ
users. The SNDSECLOG command is intended to be used as the first
command of an initial program for such a user. The command displays
a screen and requires the user to enter a 'purpose' of why he is
signing on. The command then sends a journal entry to the QAUDJRN
journal with the 'purpose'. Other SECLOG commands are used to
convert and display the information to assist in auditing *ALLOBJ
users.
- STRWTR
The Start Writer command is intended to be used to start either a
local or remote output queue. Based on the named output queue, a
command prompt appears for either STRPRTWTR or STRRMTWTR.
- WHOIS
The 'Who Is' command provides basic information about a user profile
including the last signon date and whether the user has an active
job. The information is displayed or listed. You must be authorized
to the TAARTVUSR2 authorization list.
Enhancements
- CMPPGMPARM
A new option exists to bypass the programs with no calls which
previously produced an error.
- CVTCFGSTS
A new field exists in the outfile for device category.
- DSPAUDCMD
A new parameter has been added for job number.
- DSPOBJD2
A generic object name may now be entered. A generic object name is
now also supported on CHKOBJALL, FNDOBJNAM, FNDOBJTXT, FIND2, and
CHKOBJ4.
- JOBACG
The DSPJOBACG command supports a new option to access DSPAUDCMD.
- MTNALLJRN
A new parameter has been added to allow a deletion of journal
receivers for journals in QUSRSYS that have not been saved, but have
a detach date prior to the retain date specified.
- PRTJRNRCV
New parameters have been added to allow selection on the start end
date of attachment. A total is now provided by journal in addition
to the library total.
- RTVHOLIDAY
Constitution day has been added as well as to DSPHOLIDAY.
- RTVOBJLST
A generic library name is now supported.
- RTVUSRPRF2
New return variables have been added for status (*ENABLED of
*DISABLED) and whether a password exists..
- SAVOBJIFS
The OBJTYPE parameter now allows 100 object types.
- WRKALLSPLF
An additional supported option exists for copying a spooled file to
the IFS in PDF format.
Fixes
- AUDLOG
The MTNAUDLOG command now provides a specific message when there are
no records in the AUDLOGP file to be maintained.
- CHKIFSOPN
The code did not handle the back slash character. This has been
corrected.
- CHKINACT2
The job name was not properly passed to the user USRINAC2 program.
This has been corrected.
- CPYSPLFIFS
The handling of PDF types was not wrong. Spooled files with a length
greater than 132 were truncated. The use of CHKPRDOPT was changed
from CHKSIG(*SIGNED) to CHKSIG(*NONE) to avoid setting a product to
an erroneous state. These errors have been corrected.
- CVTMSGF
The code is no longer sensitive to a specific release thus allowing
the use of the tool when a customer is on release N and has a N-1
TAA version.
- CVTPING
If the TCP3206 message showed no response, zeros were set in the
fields. The field values for PNATTP and PNSUCC were reversed. These
errors have been corrected.
- CVTSYSVAL
The function is now language independent.
- JOBACG
The MTNJOBACG command now provides a specific message when there are
no records in the JOBACGP file to be maintained.
- MAILADR
Using WRKMAILADR, some valid E mail addresses were considered in
error. This has been corrected.
- PRTAUTLOBJ
The command failed if a non-library object was controlled by the
authorization list. These are now bypassed with a count given.
- RTVCMDA
The ALLOW return value now includes *IMOD and *BMOD. The value is
also available in CVTCMDA.
- RTVLIBSRCF
The command now sends a specific escape message if one of the *SRCn
data areas is blank.
- WRKSBSJOBQ
The command failed if the library containing the job queue did not
exist. This has been corrected with a specific error message.
- WRKSPLF3
The F11 text was not correct when toggled. This has been corrected.
Incompatibilities
- CMPPGMPARM
The BYPNOCALLS parameter has been added to bypass errors caused by a
program not having any CALLs. The default is *YES which differs from
the previous way the command operated. Use BYPNOCALLS(*NO) to retain
the compatibility.
- DSPAUDCMD
*ALLOBJ special authority is now required.
2011-10-15 (R51)
New
- CALC
The Calculator tool is a series of commands that allow you to use
the system as a simple add/sub calculator and provides an optional
listing. The CLCFILP file must be created first. Many members may
exist in the file thus allowing both temporary and permanent lists
to be created and changed. Each amount entered may have an optional
text description. The last date changed exists for each record.
- CHGSGNERRT
The Change Signon Error Text tool allows changing of the error
message text for the two invalid signon messages. CHGSGNERRT changes
the text to a common value. The default text is 'Invalid signon.'
The RSTSGNERRT command restores the message text to the original
values if needed.
- CHKOBJALL
The Check Object All command provides a simple check to see if an
object name exists on the system. The library qualifier and the
object type default to *ALL. The TAA9893 escape message is sent if
the object does not exist.
- CHKSPLCTL
The Check Spool Control Authority command checks for the special
authority *SPLCTL in the current user profile or as an adopted
function. If the user does not have the function in his job, the
CPF9898 escape message is issued. Standard text describing the error
is the default.
- CMPMSGQ
The Compare Message Queue command compares the message text of
messages in two different message queues. The first 256 bytes of
each message is compared and any differences are flagged. If you are
using message queues for an application where the messages are data
rather than text, CMPMSGQ may be helpful when a duplicate message
queue is required.
- CPYCVTOUTQ
The Copy CVTOUTQ command provides a copy with selection of the
outfile (OUTQP) created by the CVTOUTQ command. CVTOUTQ creates one
record per spooled file with the attributes of each spooled file for
all spooled files in an output queue. If an output queue contains a
large number of spooled files, CPYCVTOUTQ can be used to create a
subset to allow simpler processing.
- CRTTAAPRX
The Create TAA Proxy Command command should be used when a TAA
command needs to be duplicated to a user library. A proxy command
uses the command version in TAATOOL. This allows one set of
authorizations to exist and prevents errors caused by typical
changes to a TAA command in a future TAA version.
- CVTIMGCLG2
The Convert Image Catalog 2 command converts the image catalog
entries for an Optical image catalog to a data base file. The output
file is always IMGCLGDP with a model file named TAACLGDP and a
format name IMGCLGE2.
- CVTPRXCMD
The Convert Proxy Command command converts from a command object one
record for each command in a proxy command chain. One record will
always exist for the actual command in the chain with a type of
*CMD. The QCDRCMDI API is used. The outfile is always PRXCMDP which
uses the model file TAACMFOP with a format name of PRXCMDR.
- DSPALLPRX
The Display All Proxy Commands command displays or lists all proxy
commands for an actual command. An actual command may have several
proxy commands either on the same chain or as separate chains.
DSPALLPRX will help you if you are trying to identify all the proxy
commands created for an actual command.
- DSPDAT
The Display Date command provides a convenient method of displaying
information about the current date or any date in a range of Jan 1,
1941 to Dec 31, 2040. The fully spelled out date, the day of the
week, the week of the year, and other values are shown.
- DSPJOBSCDC
The Display Job Schedule Calendar command displays the jobs that are
scheduled to run from the system job scheduler for the next 7 days
(beginning tomorrow). The listing describes the jobs to be submitted
by date and time. DSPJOBSCDC provides a good review of the jobs that
will be submitted by the system job schedule function.
- DSPOBJSRCC
The Display Object Source Change command lists objects in a named
library where the change date of the source member that was used to
create the object is more current than the object create date. If
the member does not exist, it is flagged. If a program was created
from modules, the source for the module with the most current source
change date is used for the comparison.
- DSPTXTCNT
The Display Text Count command is designed for an analysis of TXT
type members in a source file, but may be used on any source type.
One, generic, or all members in a source file may be analyzed. Total
records and blank records are always counted. Up to 5 comparison
groups (such as all the ABC values in a From/To location within a
source record) may also be compared for an equal value or scanned
for a value.
- LOOKUP3
The Lookup 3 command provides a simple lookup capability to check
whether an argument exists in an array. The array can be a large CL
variable of up to 5,000 bytes. A generic search argument is
supported.
- MOVJOB
The Move Job command moves one, generic, or all jobs from one job
queue to another. Selection may be made on a specific or generic job
or user name. MOVJOB simplifies moving jobs.
- RTVIMGCLGA
The Retrieve Image Catalog Attributes command retrieves the general
attributes about an image catalog. This includes the type, the
status, the number of directories, etc. The QVOIRCLD API is used.
- RTVSPLFINF
The Retrieve Spooled File Information command provides a fast method
of determining the number of spooled files for one or all users. The
QSPSPLI API is used.
- SCNCMDESC
The Scan Command Escape Messages command scans for a string of text
in escape messages that are sent by a specific system command. Both
the first and second level text are scanned. If the scan value is
found in the second level text, the first level text is also listed.
SCNCMDESC can be helpful when the text of an escape message is
known, but not the message ID for a specific system command.
- WRKSPLF3
The Work Spooled File 3 command works in conjunction with the
CVTOUTQ or the CPYCVTOUTQ out file. WRKSPLF3 provides a display
similar to WRKSPLF of the spooled file records in the outfile. The
use of CVTOUTQ/CPYCVTOUTQ provides better selection capability than
the system WRKSPLF command. For example, WRKSPLF does not support an
OUTQ parameter.
Enhancements
- CHKUSRCMD
New parameters have been added to provide for an outfile.
- CMPPGM
A new parameter had been added to allow a comparison of the create
date/time.
- CPYFRMOUTQ
A new parameter had been added to allow sequencing
- CPYSPLFIFS
A new STMFTYPE has been for *PDF to allow conversion to a PDF type.
See the command help text for the proper requirements.
- DSPPERTAA
The new CALC tool has been added as an option.
- DUPTAACMD
The command now uses the new CRTTAAPRX command to create a proxy
command in the specified library instead of a regular command. of
the files by job, open date/time.
- FNDCMD
A new option has been added to allow a display of the command
attributes.
- RMVOLDMSG
A new option has been added to allow a completion message if the
only errors are caused by failures to allocate message queues.
- RTVSPLFA
A new parameter has been added for CODEPAGE.
- RTVUSRPRF2
New parameters have been added for ASTLVL, LMTCPB, SUPGRPPRF,
PRVSIGN, and whether the user has an active job.
Fixes
- CHKACTUSR2
In some cases the WRKACTL compiler source listing was not deleted.
This has been corrected.
- CVTOBJD4
The tool failed if a large number of objects had to be converted and
exceeded the user space size. The tool has been reworked to use
DSPOBJD to an outfile and then copied to the specified file.
- DLTDEPLGL
If a physical file did not have any members, the command failed
attempting to allocate the file. This has been corrected.
- DLTOLDQRPL
The command failed if an object was locked. Locked objects are now
bypassed with a diagnostic. More object types are now deleted
properly. The internal file in QTEMP is now ensure to be set at
*NOMAX size.
- MOVSPLF
A MONMSG was added to CHGSPLFA for CPF3303. The same MONMSG was also
added to other tools.
- MTNALLJRN
The command failed on a generic library name. This has been
corrected.
- PRTLVLCHK
The return code was set to *UNKNOWN if the file was already known to
the internal file. This has been corrected.
- RTVCALLR
The name of the current program was being passed back for OPM
programs. This has been corrected.
- RTVCMDA
If more than 5 proxy commands existed, RTVCMDA failed. This is now
restricted and partial information is returned. If the name of the
proxy command differed from the actual command, the RTNLIB parameter
was wrong. This has been corrected.
- RTVJOBSTS
If more than 200 jobs satisfy the selection criteria, the command
completes normally with a diagnostic message explaining that only
the first 200 were processed.
- RTVLFSRC
The command should have been specified as ALLOW(*ALL). This has been
corrected.
- RTVOBJLCK
The command failed with a CPF9803 message. This has been corrected.
- SAVE2
Option 21 now correctly describes that spooled file data may be
optionally saved.
- SCNALLJLG
If job logs were scanned, but no selection criteria matched, the
command failed. This has been corrected.
- WRKFAVCMD
The '?' option is now prevented if there is already a leading '?' in
the command.
Incompatibilities
- CLRLIB2
Both *JOBCTL and *ALLOBJ special authority are now required.
2011-07-15 (R50)
New
- CHKACTUSR2
The Check Active User 2 command is designed for the situation where
you periodically want to check for a list of users to see if they
are active. On the first use or when RESET(*YES) is specified, a
file is built in QTEMP of the active users. The file is then checked
to see if the specified user is active and if not, an escape message
is issued. On subsequent uses with RESET(*NO), only the file is
checked.
- CHKHEX
The Check Hex command checks a string of hex characters such as
'C1C2C3' to ensure valid hex characters exist. A string of up to 512
characters may be checked. You must use the RTNLOC value to
determine if an error exists. CHKHEX can be helpful when a user is
entering hex characters which must be validated.
- CMPMBRD
The Compare Member Description command compares attributes of one,
generic, or all members (either data or source) in two different
files. Only the member text, number of records, number of deleted
records, and 'share' attribute are compared. Unmatched member names
in the To file are flagged. Unmatched member names in the From file
may be optionally flagged. CMPMBRD may be helpful when ensuring
member attributes are identical in two files.
- CVTDAYS
The Convert Days command converts a range of dates to an outfile.
The BUSCAL tool must first be used to a build a Business Calendar (a
*USRSPC object) with the years that you want to consider. Days such
as Sunday, New Years, Christmas, and specific dates may be excluded.
CVTDAYS is then used to build an outfile of dates that have not been
excluded.
- DSPEMTIFS
The Display Empty IFS command is a front-end to DSPIFS to provide a
listing of the empty IFS stream files. Stream files that have an
object size of 0 are displayed. Note that this is not the allocated
size of the stream file. The DSPIFS command is used internally and
the output appears with the title of 'Display IFS'.
- DSPOUTFMT
The Display Outfile Format command displays the fields in a format
of the model file for commands that create outfiles. Many DSP
commands and CVT commands support an outfile. Both system and TAA
commands are supported. If multiple outfiles exist for the command
(eg DSPFD), the DSPOUTFILE command is used to allow a selection.
DSPOUTFMT may only be used interactively.
- DSPPRFAUT
The Display Profile Authorizations command displays one, generic, or
all profiles and flags those where the *PUBLIC or an authorized user
has at least *USE rights to the user profile. The owner, *ALLOBJ
users, and certain system profiles are bypassed. The user profiles
that are flagged represent a security exposure as the *PUBLIC or
authorized user can submit a job as the user profile or swap to the
user profile.
- DSPQHSTSIZ
The Display QHST Size command provides a simple listing with one
line per QHSTxx file in QSYS and the total size. The date/time of
the first and last message of each QHST version is also included
along with the save date. This allows a review of QHST versions.
- EDTUSRSPC
The Edit User Space command allows data to be written or changed in
a user space. An option on the command allows editing in character
or hex mode. EDTUSRSPC provides a convenient method of storing and
maintaining data in a user space object or making changes when data
is written to a user space by another function.
- FIXVAR
The Fix Variable command allows an input variable to be changed by
replacing a character with one or more characters (up to 10) or
deleting a character. The new value is returned in a 5000 byte
variable. The input variable may be up to 5000 bytes, but a length
should be specified to improve performance.
- OUTFFLD
The Outfile Fields tool is a series of commands that allow you to
display a field name that exists in either a system and/or TAA model
file. This can assist in understanding the attributes of the field
and the command which outputs the file. After the required files are
created and the field information is converted, the DSPOUTFFLD
command can be used.
- PRTPAGOF
The Print Page Of command allows you to re-print a spooled file
where you have printed 'Page n' and change the value to 'Page n of
n'. You must identify where the units position of the page number is
and the line it is to print on. After re-printing, the original
spooled file is deleted.
- RTVMTHNAM
The Retrieve Month Name command retrieves the name of the month
based on a plus or minus number of months from the current month.
Different formats of the month name are provided. The system date is
used to determine the current month (not the job date).
- RTVOBJLCK
The Retrieve Object Lock command is designed to assist when an
object is locked and you suspect there may be a single job holding
one or more locks on the object. If only a single job holds one or
more locks, return variables will describe the job and the strongest
lock to allow a message to be sent. If locks exist from multiple
jobs, the TAA9891 escape message is issued.
- RTVSBMCMD
The Retrieve Submitted Command command retrieves the command that
was submitted by a SBMJOB. The job may be on a job queue, be active,
or have completed as long as DSPJOBLOG can be used. The command for
the first 'Request' type message is returned. Several restrictions
exist.
- SAVRSTJOBQ
The Save and Restore Job Queue tool supports two commands to provide
for a save and restore of a job queue. CVTJOBQ2 creates an outfile
of information about the jobs on a job queue. The file can be saved
and restored to the same or a different system. The SBMJOBQ2 command
may then be used to read the outfile and perform a SBMJOB for each
job found in the outfile. Some restrictions exist.
- SCNALLJLG
The Scan All Job Logs command will scan all or selected job logs for
various criteria such as message IDs, message types, and a string of
text. If a match is found, an abbreviated spooled file is written
named JOBLOG. SCNALLJLG assists in finding information when the
specified job log is not known. Selection criteria is an important
consideration as significant performance considerations exist if
many job logs are scanned (see the discussion on performance).
- SCNMSGQ
The Scan Message Queue command scans, one, generic, or all message
queues in one or more libraries for up to 20 different arguments
against the message text of the messages. A listing is output of the
messages that match at least one of the arguments.
- SCNVARRGT2
The Scan Variable Right 2 command scans a variable (up to 5000
bytes) for either the length of the data or for a string. SCNVARRGT2
can help determine the length of the data in a large variable or
where a string of characters begins.
- SIGNOFF2
The Signoff 2 command operates as a normal signoff command except
that ENDCNN(*YES) is the default instead of the system default of
*NO. SIGNOFF2 is intended to be used when TELNET is used to start a
job on another system. SIGNOFF2 may only be used during an
interactive job. The command is specified as LMTUSR(*YES).
- SNDPGMMSG3
The Send Program Message 3 command allows a *DIAG, *COMP, or *INFO
message to be sent to the caller from a sub or sub-sub program. This
can provide better feedback when the sub program needs to
communicate to the caller of a program. The QMHSNDPM API is used to
allow the message to be sent up the stack.
Enhancements
- CLRLIB2
If one or more objects cannot be deleted, a listing
- CMPDBF
A better explanation of the differences is now displayed the number
of records differ.
- CVTIFS
New support for multiple * values in the SELECT parameter to allow
searching on a partial name and strings of characters.
- CVTLIBAUT
A new physical (TAASEIIP) and logical (TAASEIIL) have been added.
The files are not used by CVTLIBAUT, but allow another program to
define the keyed logical by library, object, and object type. An OBJ
parameter has been added to allow selection by object name, generic
name, or all.
- CVTWRKUSR
Additional fields have been added to the outfile for the date/time
the job entered the system, the date/time the job went active, the
date/time the job ended, and the job completion status.
- DLTLIB2
If one or more objects cannot be deleted, a listing is output of
each error.
- DSPAUDLOG
New parameters have been added to allow the current or job user to
appear on the subfile display and an end date/time.
- DSPIFS
New support for multiple * values in the SELECT parameter to allow
searching on a partial name and strings of characters.
- DSPONLINE
An option has been added for the new DSPOUTFMT command.
- DSPUSRSGN
Average response time has been added to the listing.
- EXPVAL
A new optional return parameter may now be specified to allow for up
to 5000 bytes.
- FNDJOB
A new selection criteria has been added for job type.
- PRTSECAUD
The CHKSAMPWD option now uses the system ANZDFTPWD command which
produces a separate listing. This avoids any changes to the internal
count of invalid passwords entered.
- RTVJOBA2
New parameters have been added to RTVJOBA2B for allow multiple
threads, spooled file action, job log output.
- SCNOUTQ
A new command parameter exists to allow the output format to list
one line for each argument found, the job, user, job number, spooled
file name, etc.
- SPLARC
A new command DLTSPLARCD has been added to delete duplicate audit
records. This can occur if a spooled file is archived and then moved
to a different output queue. A duplicate must match on the system
name, job, user, job number, spooled file name and number, open date
and time, and user data to be deleted.
A new command RMVSPLARCM has been added. This is a cleanup command
that would normally not be used. It will remove members from the
save files if a corresponding audit record does not exist.
- WRKALLSPLF
A new option exists for PRTPAGOF.
Fixes
- AUDLOG
The DSPAUDLOG USER parameter was checking for the job user and not
the current user. This has been corrected.
- CHGJOBANZD
The command produced the wrong result if more than 1000 seconds were
entered. This has been corrected.
- CHGOBJAUT2
The command failed on RTVLIBD if *CURLIB was passed. The actual
current library is now used.
- CHGOBJAUT2
The command failed unless the outfile library was QTEMP. This has
been corrected.
- CMPDBFFMT
A better explanation of differences in the file attributes is now
provided.
- CMPSRC2
The FROMFILE parameter allowed an *ALL value which was not
supported. *ALL has been removed from the command.
- CRTSPLARC
*ALLOBJ authority is now required.
- CVTLIBAUT
The selection criteria was not handled properly. This has been
corrected.
- CVTMBRD
If a file other than CVTMBRP was requested, the file size is now set
to *NOMAX.
- CVTMBRLST
The command failed unless the outfile library was QTEMP. This has
been corrected.
- CVTOBJD4
The command prevented operations on TAATOOL. This has been
corrected.
- CVTPGMA2
The module information was offset in the outfile. This has been
corrected.
- CVTQRYUSE
The command was not properly handling join files created with inner
and outer join.
- CVTSYSVAL
The command processing is now more tolerant of non-English
languages.
- CVTWRKSPLF
Generic spooled file names were not handled. This has been
corrected.
- DLTIFS
When an IBM owned directory was specified with DLTDIR(*NO), an
escape message was issued. Another error has been found dealing with
directories in QDLS. These errors have been corrected.
- DLTOBJ2
If OBJATTR(*ALL) was specified with a generic object name, the
logical files were not being deleted first. This has been corrected.
- DLTOLDQRPL
If no objects existed in the library, an escape message occurred.
This has been corrected.
- DMOSUBF
The *GENERIC control function was not handled properly. This has
been corrected for DMOSUBF and DMOSUBF2.
- DSPQHST
The command failed on blank dates returned from a sub program. This
has been corrected.
- DSPZIP
The command was out of synch with the parameters of the CPP. This
has been corrected.
- JOBACG
For ANZJOBACG, CMPCDE(*FAILED) now bypasses code 99 (job accounting
segment).
- PRTPRM
The PRTPRMCMD is now tolerant of errors for commands
- RGZLIB
Some combinations of parameters are invalid on RGZPFM such as
ALWCANCEL(*NO) with LOCK(*EXCLRD). These are now diagnosed by
RGZLIB. ALWCANCEL(*YES) may only be used if the file is journaled.
If it is not journaled, the file is flagged and bypassed. Any
remaining files are processed.
- RTVFMT
In some cases the file text was returned as blanks.
- RTVJOBA2
The CYMDDATE value on RTVJOBA2B was set to blanks for a job on a job
queue. The SYSLIBL and USRLIBL parameters were being returned as 10
character library names instead of 11. These errors have been
corrected.
- RTVLFA
The WAITRCD(*NOMAX) value was returned as blanks. This has been
corrected.
- SAVLIBIFS
The SNDJLGMSG failed if the text exceeded 256 bytes. This has been
corrected.
- SCNALLSRC2
The handling of multiple arguments was wrong. This has been
corrected.
- SCNOUTQ
The size of the TAA378 internal file is now *NOMAX.
- TRNVAL2
The input value field should have been declared as *CHAR LEN(1000).
This has been corrected.
Incompatibilities
- CLRLIB2
TAA9896 is now sent as an escape message if the library cannot be
cleared.
- DLTLIB2
TAA9896 is now sent as an escape message if the library cannot be
deleted.
- DSPONLINE
Some of the option numbers have changed.
- PRTSECAUD
The CHKSAMPWD parameter now uses the system ANZDFTPWD command to
produce a separate listing. The prior technique caused a change to
the internal count of invalid passwords entered for those user
profiles that had a name that differed from the password. The new
technique does not cause any change to the internal count of invalid
passwords entered.
- SCNOUTQ
TAA9893 is now sent as an escape message if no arguments are found.
2011-04-15 (R49)
New
- CHGCNLKEY
The Change Cancel Key command works in conjunction with the
RTVCNLKEY tool command. CHGCNLKEY allows the setting of the Cancel
and Exit key information which may be of value when mixing system
and user functions. The QWCCCJOB API is used.
- CHGDBFDAT
The Change Data Base File Date command changes date fields in a file
from an MMDDYY, DDMMYY, or YYMMDD format to a different format. This
allows rearranging date fields to allow for normal processing based
on your typical date format.
- CHGDSPOBJO
The Change DSPOBJD Outfile Dates command changes all date formats in
the outfile created by DSPOBJD that are in an MMDDYY format to
either DDMMYY or YYMMDD. The DSPOBJD outfile has several date fields
that use the MMDDYY format regardless of the job date format.
CHGDSPOBJO makes it easier to work with the dates if you want a
format other than MMDDYY.
- CHKARASPE
The Check Data Area Spelling command checks for misspelled words in
a *CHAR type data area (*DTAARA). The data in the data area would be
considered as a string with blanks separating the words. The
dictionary supplied by TAA is used by default. Special dictionaries
may be named. See the discussion with the TAADCT tool.
- CHKSPCSPE
The Check User Space Spelling command checks for misspelled words in
the first 32,000 bytes of a user space. The data in the user space
would be considered as a string with blanks separating the words.
The dictionary supplied by TAA is used by default. Special
dictionaries may be named. See the discussion with the TAADCT tool.
- CLCBOOLVAL
The Calculate Boolean Value command provides input of 2 arguments of
4 byte fields and returns the result in either or both a 4 byte
character value or an 8 byte hexadecimal value. The operation
performed can be *OR, *AND, XOR, *NOR, *NAND, or *NOT. The arguments
must be 1-4 byte *CHAR type fields. They may be variables, literals,
or hex values.
- CLRGENMBR
The Clear Generic Members command clears one or more generic members
in a data base file (either source or data). The system supports a
generic capability on RMVM, but not on CLRPFM. CLRGENMBR provides
the missing function to allow cleanup of certain files.
- CVTAUTL
The Convert Authorization List to Outfile command converts
individual authorities for one, generic, or all authorization lists
to an outfile. This allows various processing or queries against the
information. The outfile is always AUTLP which uses a model file
named TAASEIUP and a format name of QSYDSAUT.
- DSPAUDCMD
The Display Audit Command command displays or lists audit records
for a specific user for the AUDLVL(*CMD) function. The AUDLOGP file
(AUDLOG tool) is used. The user must be specified as CHGUSRAUD
AUDLVL(*CMD) which causes an audit entry for each command executed
(including commands run in CL programs or REXX procedures).
DSPAUDCMD provides a tailored solution for the 'T CD C' journal
entries.
- DSPQHSTINQ
The Display QHST Inquiries command displays or lists inquiry
messages and their replies from the QHST log. The formatting allows
a better review than the DSPLOG command. A detail option for
additional information is available.
- DSPUSRAUT3
The Display User Authority 3 command displays or lists the
authorities that have been granted to a specific user for one,
generic, or all objects. A specific object type may be named.
Inclusion of the user's owned objects is an option. DSPUSRAUT3
provides a better review than DSPUSRPRF.
- DSPUSRSGN
The Display User Signon command displays the hours and minutes that
one or more users were signed on. The JOBACG tool is required and
the latest job information must be converted from the QACGJRN
journal. The default option lists each signon by a user (from any
device) with day and user totals for the days requested. You may
request a day total or just a user total.
- EXTLST3
The Extract List 3 command accepts input from a simple list
parameter passed from a command and returns a value that is suitable
to be moved to a variable for listing or displaying in a message.
One space would exist between each value returned. The command would
typically be part of a CPP that needs to make the list displayable
and not as it is passed to the program.
- RCVMSGKEY
The Receive Message Key command receives a message from the job log
(intended for a low level message). You must first run the RTVMSGKEY
command (part of the RMVMSGKEY tool) to set a mark in the job log
prior to running the function that produces low level messages. Then
RCVMSGKEY may be used to receive either a specific message ID or a
loop may be written to receive more than one message.
- RMVMSGKEY
The Remove Message Key tool provides two commands (RTVMSGKEY and
RMVMSGKEY) which should be bracketed around commands that produce
messages (including low level messages) that need to be cleaned up.
When developing CL programs, it is desirable to cleanup messages
produced by functions within the program. Many system commands send
messages to low level programs that cannot be removed by RMVMSG
CLEAR(*ALL).
- RNMIFSXLT
The Rename IFS with Translation command renames directories and
files described in a CVTIFS outfile (*TYPE2). Renaming is done
character by character for up to 10 different characters that may be
replaced. Unmatched characters are not changed. RNMIFSXLT can be
helpful when transferring IFS objects to different system types
which have different naming conventions.
- RSNMSGKEY
The Resend Message Key command resends messages from the job log
(intended for low level messages). You must first run the RTVMSGKEY
command (part of the RMVMSGKEY tool) to set a mark in the job log
prior to running a function that produces low level messages.
RSNMSGKEY may then be used to resend either a specific message ID or
all messages from the RTVMSGKEY mark.
- RTVCNLKEY
The Retrieve Cancel Key command retrieves the action of the last
system display function (including the command prompter) and returns
the setting of the Cancel and/or Exit key. This allows a program
using the display to determine whether the display was ended with
the Enter key versus the Cancel or Exit key. The QUSRJOBI API is
used to retrieve the information.
- RTVSYSVAL4
The Retrieve System Value 4 command is an alternative method of
accessing a single system value. It differs from RTVSYSVAL2 in that
the return variable allows for 5000 bytes instead of the 900
supported by RTVSYSVAL2. The command interface is not of particular
value, but the CPP can be called directly as an API which allows a
simple access to any system value from a HLL.
- SCNSRCSEU
The Scan Source SEU command scans one or more members in a source
file for up 20 different arguments. If an argument is found, STRSEU
is used on the member in either *CHANGE or *BROWSE mode. SCNSRCSEU
simplifies making changes or reviewing source when several members
have used the same string of characters.
- SORTRPGARR
The Sort RPG Array command sorts compile time array data into
ascending sequence for a named array in an RPG type source member.
This simplifies making source changes to compile time array data
when it is required to be in ascending sequence.
- SYSLIBL
The System Library List tool is a documentation member only to help
understand the basics of how to control and audit the changes to
libraries on the system library list. TAA Tools that can assist are
also mentioned.
Enhancements
- CMPALLSRC
An outfile capability has been added.
- CMPSRC2
An outfile capability has been added.
- DLTIFS
New keywords have been added for ATRCHGDATE, DTACHGDATE, and
ACCDATE. Better formatting and additional final counts have been
added.
- DSPOBJAUD
A new keyword has been added to allow selection on the type of
auditing.
- JOBACG
The 20 byte journal sequence number is now supported. The ANZJOBACG
command supports new sequencing options and intermediate totals for
several options.
- MTNJRN
A new option exists for the SAVINQMSG that allows bypassing any
journal receivers that have not been saved.
- PRTACG
The 20 byte journal sequence number is now supported. Additional
fields exist in the PRTACGP file for the spooled file open date and
time.
- RGZLIB
A new keyword has been added for LOCK and *OPTIMIZE has been added
to the RBDACCPTH keyword.
- RPLPGM
A new keyword has been added for GENLVL. The same parameter has been
added to RPLMOD, RPLOBJ, and CRTTGTRLS.
- SCNAUDLOG
A new keyword has been added to allow bypassing of up to 10 user
names.
- WRKALLSPLF
F3/F12 may now be used to end processing during a function. For
example, if 5=DSPSPLF is used for multiple spooled files, F3/F12 may
be used during the DSPSPLF display to return to the WRKALLSPLF
subfile.
Fixes
- AUDLOG
CRTAUDLOG now creates the file with a *NOMAX record size. The same
change has been made to the PRTACG file PRTACGP.
- CHKINACT2
If no activity occurred, the batch program failed. This has been
corrected.
- CHKOLDOBJ
The TAATMPOBJ2 file in QTEMP is now set to *NOMAX.
- CVTARPTBL
The field ARENTY was always set to PROXY. This has been corrected.
- CVTLIBAUT
If an outfile library other than QTEMP was named, the outfile data
had only 2 records. This has been corrected.
- CVTLIBDBF
Special value names for the LIB parameter were failing on CHKGENERC.
This has been corrected.
- CVTMBRLST
Generic member names were not being supported. This has been
corrected.
- CVTWRKSPLF
The From date value of *AVAIL was failing. This has been corrected.
Additional corrections have been made when using a sub procedure and
the handling of errors. In some cases the server job was not able to
keep up and assumed there were no more spooled files. This is now
handled correctly.
- DLTIFS
If DLTDIR(*NO) was specified and the directory was empty, it was
being deleted. This has been corrected. It is no longer considered
an error if after selection one or more objects exist in the
directory.
- DSPARPTBL
The field ARENTY was always set to PROXY. This has been corrected.
- DSPJOBQ
The sequence of the jobs did not reflect the scheduled date and time
for SCD jobs. This has been corrected.
- EDTOBJAUT2
The command failed if the authorized user was *GROUP. This has been
corrected. A restriction now exists that the *GROUP authorizations
cannot be changed (any other user profile can be including *PUBLIC).
- JOBACG
The PRTJOBACG3 command did not print the start date date properly if
a special value was used. The ANZJOBACG command was not properly
displaying average response time. These errors have been corrected.
- RTVCMDPARM
A value such as DFT('') was not handled. This has been corrected.
- RTVVALA
Values with lengths greater than 16 were failing if they had digit
values. They are now automatically considered as character.
- SELMAILADR
The number of mail addresses failed after 50 entries. This has been
fixed to allow 9999.
- WRKIPDEV
The F6 print function did nothing. This has been corrected.
- WRKSPLF2
The From/To dates were not being handled correctly This has been
corrected.
Incompatibilities
- CVTJOBACG
The format of the files used by job accounting has changed. Follow
the instructions when the error message is displayed when using
CVTJOBACG.
- CVTPRTACG
The format of the files used by print accounting has changed. Follow
the instructions when the error message is displayed when using
CVTPRTACG.
- WRKALLSPLF
If multiple options are entered for spooled files on the subfile
display (or F6 to display all), the F3 and F12 keys will now return
to the subfile display. The Enter key should be used to advance to
the next spooled file. This avoids the problem of having to invoke
every option or cancel request to end.
2011-01-15 (R48)
New
- CHGAUT2
The Change Authority 2 command is a simple front end to the system
CHGAUT command that operates only on objects in a library. Multiple
users may be specified, but not all CHGAUT functions are supported.
Unlike GRT/RVKOBJAUT, there are no low level messages that clutter
the job log and cannot be removed.
- CHGBIT
The Change Bit command allows one or more bits to be changed in a
byte to either *ON ('1') or *OFF ('0'). The bits are numbered 1 - 8
with 1 being the high order bit. A variable must be specified for
the &RTNBYTE parameter and all BITn parameters cannot be specified
as *SAME.
- CHKBIT
The Check Bit command checks one or more bits in a byte for an on or
off value ('1' or '0'). The bit positions are labeled 1-8 with 1
being the high order bit. TAA9892 is sent if the bits do not match
the requested values.
- CHKFMT
The Check Format command checks for a format and/or level ID in a
file. File types that support formats may be specified. A specific
format may be named or the special value *FIRST. Different escape
messages are sent if the format does not exist or the level ID does
not match. No completion message is sent if the command completes
normally.
- CHKIFSSPE
The Check IFS Spelling command checks the spelling of the data in a
stream file. The data is converted to the TAA240 source file in
QTEMP and the TAA CHKSPELL2 command is used to check the spelling.
Error indications appear with sequence numbers as if the data was in
a source file. The data is limited to 240 bytes wide for the stream
file.
- CHKTAALIC
The Check TAA License command provides a simple check to see if a
valid TAA Productivity Tools license exists. The completion message
describes whether a full or demonstration license exists. If a
demonstration license exists, the date the license expires is
described.
- CRTRTVDCL
The Create Retrieve DCLs command creates DCL commands in a CLP
source member for a named RTV command. Rather than keying the DCLs
manually, CRTRTVDCL may be used to generate all the DCLs for a
retrieve command that allows return variables. The source member
must exist.
- CVTMBRLST2
The Convert Member List 2 command converts the member description
information for one, generic, or all members of a file. The output
file is the same as that used by DSPFD *MBRLIST. The DSPFD command
does not allow a single or generic member name. CVTMBRLST2 makes it
simple to create a function that processes one, generic, or all
members from a file.
- DLTENDLIC
The Delete End TAA License command provides a method of resetting
the TAA license if ENDTAALIC had been used previously. This is
intended for a situation where a mistake has been made or a change
of plans has occurred after ending the TAA license. DLTENDLIC
requires a special software code that may be requested from the TAA
Productivity Tools owner.
- DLTGRCKEY
The Delete Grace Key command is a companion command to CRTGRCKEY.
CRTGRCKEY is used to allow the use of the TAA Tools for a grace
period on a system that does not have a valid license. CRTGRCKEY may
only be used once on a system unless a reset occurs. DLTGRCKEY
provides a reset function, but requires a special software code that
may be requested from the TAA Productivity Tools owner.
- DSPDBFDMG
The Display Data Base Damage command checks for damage in the data
base file descriptive information. Each file processed is used by
CHKOBJ, RTVOBJD, various forms of DSPFD, and DSPFFD. An outfile of
the damaged files is optional. The data itself is not checked.
DSPDBFDMG is intended for the case when an abnormal system
termination has occurred and you suspect data base damage.
- DSPDSTQ
The Display Distribution Queue command is a simple front end to the
system WRKDSTQ command. Only a display is provided so no changes are
allowed. WRKDSTQ is set as *PUBLIC(*EXCLUDE). DSPDSTQ adopts the
authority of QSECOFR so that any user may review the contents of a
distribution queue or all distribution queues.
- DSPMSGQINQ
The Display Message Queue Inquiries command displays or lists
inquiry messages and their replies from a message queue such as
QSYSOPR. The formatting allows a better review than the DSPMSG
command. A detail option for additional information is available.
- DSPPMTCMD
The Display Prompted Command function prompts for a command and uses
the returned string to 1) run the command via user specified QCMDEXC
program, 2) parse the returned string into 68 byte blocks to be
displayed, printed, sent to the job log, or written to a source
member. Variables may be specified for the parameters of the command
to be prompted for and will be filled at execution time. The
variables must be declared in the program.
- DSPSPCAUT2
The Display Special Authority 2 command displays the combination of
special authorities for a user, the group profile, and any
supplemental group profiles. Selection can be made on the combined
special authorities. DSPSPCAUT2 helps provide a better view of what
an individual user can do.
- DSPUIMCNT
The Display UIM Count command counts the number of lines in one or
more members containing UIM type source. Source types in addition to
PNLGRP may be specified. Comment lines and blank lines are also
counted. A percentage of comments is provided. DSPUIMCNT provides a
better understanding of the amount of actual source versus a count
of the number of statements in a source member.
- FMTQLFCMD
The Format Qualified Command command allows CL source to be
formatted so any qualified commands begin in position 14 of the
source with the command name. The / is placed in position 13 and the
library name to the left. This aligns the command names for easier
reading of the source. The command prompter formats a qualified name
so the library name begins in position 14.
- FNDOBJMBR
The Find Object Member command attempts to match the source member
name used to create an object with a source member in one or more
source files. This is designed for the case where the source has
been moved or duplicates exist for the same member name. One or more
objects may be specified with one or more libraries checked for
where the source may exist.
- RTVPMTCMD
The Retrieve Prompted Command command allows an input of a command
string (such as just a command name), prompts for the command, and
then returns the full command string including keywords without
executing the command. Different formats are available such as for a
command line or in a CLP source format. RTVPMTCMD is useful to
applications that want to allow command input with prompting so the
return command string can be run at a later time.
- WRKFATHOM
The Work Fathom command provides an interactive display to convert
from fathoms, feet, cable lengths, nautical miles, and miles to
different values. By entering a non-zero value on the left of the
display and pressing Enter, the screen is refreshed with the
converted value.
Enhancements
- BUSCAL
A new special day value has been added for Christmas Eve.
- CHGJOBSPLF
Selection may now be made on a generic spooled file name.
- CHGOBJAUT
The DLTSPLF(*YES) function no longer creates a spooled file which
improves performance. If an error occurs, an immediate escape
occurs.
- CHKTAAPRD
An indication now occurs for whether the objects found outside of
TAATOOL were created from a TAA Tool object.
- DSPHOLIDAY
*CHRISTMASEVE has been added and also to RTVHOLIDAY.
- DSPLIBSRCF
The number of members in each file has been added to the listing.
- DSPOBJD2
An indication now occurs if the object last source change date is
'down level' from the source member change date.
- JOBACG
Several commands now support the capability to search on the current
user. The ANZJOBACG command prints intermediate total for a SEQ
value of *USER or *JOB.
- PRTMBRSUM
A sequence parameter has been added to allow sequencing on the
number of members, the size, and save date.
- PRTSRCSUM
A sequence parameter has been added to allow sequencing of the
members within a file on the number of records, the create date, or
the change date.
- RGZLIB
An optional outfile has been added that will contain one record for
each physical member reorganized.
Fixes
- ANZJOBACG
The user profile name did not print in all cases. If no records
exist, the command failed attempting to convert a blank date. The
page counter was only 4 digits (increased to 7). These errors have
been corrected.
- CHKDBFMBR
The command did not return the type of file if MBR(*NONE) was
specified. This has been corrected.
- CPYSPLF2
Some merged overlaid lines were not being printed. This has been
corrected.
- CPYTOCSV
Date, Time, and Timestamp field data was dropped. This has been
corrected.
- CPYUSRPRF
The owner of the original user profile was not copied to the new
profile in all cases.
- CRTTSTJRN
The IMAGES prompt now allows *BOTH instead of *BEFORE. Logical files
were not being handled properly. This has been corrected.
- CVTIFS
An error occurred when the OBJ parameter was longer than one byte
and ended with a /. The same error also occurred with RTVIFSED,
RTVIFSED2, and DSPIFSED. These errors have been corrected.
- CVTLIBDBF
If a generic library name was entered, no files were output. This
has been corrected.
- CVTOBJD2
If the library qualifier was *ALL or *ALLUSR, a check for *ALLOBJ
was not made. This has been corrected.
- CVTQHST2
A very long length of the message data caused an index error. This
has been corrected.
- DLTIFS
The previous change caused an error when no deletions occurred. In
some cases, the internal OPNQRYF command used overlaid data. This
and other minor errors have been corrected.
- DSPDBFREL
Not all parameters were passed to TAADBHOC2. This has been
corrected.
- DSPHOLIDAY
*CHRISTMASEVE has been added and also to RTVHOLIDAY and CHKHOLIDAY.
- DSPJOBQ
The sequence of the display has changed so that date/time the job
was placed on the job queue is now part of the sort following the
priority.
- ENDTAALIC
Ending the license in the last 3 months of the year caused a demo
date in early of the same year. This has been corrected.
- HELPTAA
Option 50 for TAA Updates caused an error. This has been corrected.
- NBRCTR
If WRAP(*YES) was specified, wrapping occurred one less that the
maximum. This has been corrected.
- RGZLIB
RBDACCPTH(*OPTIMIZE) failed with a truncated value. This has been
corrected.
- SAVSNDM
If a single member was requested, the command failed attempting to
delete a user space. This has been corrected.
- SCNUSRPRFA
In some cases, incorrect values were returned. This has been
corrected.
- SNDOBJLCKM
Multiple locks from the same job were not always handled properly.
This has been corrected with a change to RTVJOBA2.
- SNDSPLMAIL
To prevent duplicate DLO object names being created by different
jobs, the SUBJECT parameter now defaults to *NOTUSED and a naming
convention is used for the subject (as seen by in the completion
message and by the recipient). If commands were issued frequently,
deleting the DLO object failed because the system retained a lock. A
loop is now used of 4 times with 2 second delays attempting to
delete the object. If it cannot be deleted, a diagnostic message is
sent.
The command failed when the E-Mail address contained characters used
in an express such as a minus sign. All addresses are now enclosed
in apostrophes. The same change has been made to SNDIFSMAIL,
SNDTXTMAIL, and other IFS commands.
- WRKIPDEV
An internal value was compared incorrectly which produced the wrong
number of devices in some cases.
Incompatibilities
- CHGOBJAUT
The DLTSPLF(*YES) function has been changed to no longer create a
spooled file. No external difference will occur unless an error
situation arises in which case an immediate escape message is
issued.
- SNDSPLMAIL
The SUBJECT parameter is no longer used and any value is ignored.
SUBJ now defaults to *NOTUSED. The subject value sent will now
contain a unique value followed by '.TXT'. This change was required
to prevent an error when the same subject value was used by multiple
users thus creating a duplicate DLO name.
2010-10-15 (R47)
New
- CHGOBJAUT2
The Change Object Authority 2 command changes the *PUBLIC user of an
object to the CRTAUT value of the library where the object exists.
If the library value is *SYSVAL, the QCRTAUT system value is
accessed and used. CHGOBJAUT2 allows existing objects to have their
authority changed to adhere to the library default.
- CRTTGTRLS
The Create Target Release command assists in creating or changing
objects to be saved for a named release. A specific or generic
object is named or all objects in a library. Either a new library
must be named and must not exist (it is created by CRTTGTRLS) or the
objects in the same library will be created for the named release.
The TAA Tool RPLOBJ is used to recreate program and module objects
and produces a listing of the results.
- CVTJOB
The Convert Job to Outfile command converts the information for one
or more jobs to an outfile. Selection may occur on the job or user
name as well as the status (*ALL, *ACTIVE, *JOBQ, *OUTQ). The
outfile name is JOBP which uses the model file TAAJOFKP and a format
name of JOBRCD.
- DSPCOMPCDE
The Display Completion Codes command displays the job completion
codes described in the CPF1164 message. This provides a quick
review.
- DSPEMTARA
The Display Empty Data Area command displays one or more data areas
that have no value or a zero value (*DEC type *DTAARA). A flag may
be set if the data area has not been changed (such as by CHGDTAARA)
in the last n days. An option exists to list all data areas.
DSPEMTARA can be helpful in cleaning up unused data areas.
- DSPEMTDBF
The Display Empty Data Base File command displays data base files
that have no members. A flag may be set if the data base file has
not been used in the last n days. An option exists to list all data
base files. DSPEMTDBF can be helpful in cleaning up unused data base
files.
- DSPEMTDTAQ
The Display Empty Data Queue command displays one or more data
queues that have no entries. A flag may be set if the data queue has
not been changed (such as not having received an entry) in the last
n days. An option exists to list all data queues. DSPEMTDTAQ can be
helpful in cleaning up unused data queues.
- DSPEMTJOBQ
The Display Empty Job Queue command displays one or more job queues
that have no jobs. A flag may be set if the job queue has not been
used (such as not having any jobs added) in the last n days. An
option exists to list all job queues. DSPEMTJOBQ can be helpful in
cleaning up unused job queues.
- DSPEMTMSGQ
The Display Empty Message Queue command displays one or more message
queues that have no messages. A flag may be set if the message queue
has not been changed (such as not having received a message) in the
last n days. An option exists to display all message queues.
DSPEMTMSGQ can be helpful in cleaning up unused message queues.
- DSPEMTOUTQ
The Display Empty Output Queue command displays one or more output
queues that have no entries. A flag may be set if the output queue
has not been used (such as not having any spooled files) in the last
n days. An option exists to list all output queues. DSPEMTOUTQ can
be helpful in cleaning up unused output queues.
- DSPJOBSCDR
The Display Job Schedule Results command displays the results of Job
Scheduled jobs (how they completed) for the last submission. The
JOBACG tool must be in use and the job accounting entries must be
current for the completed Job Scheduled jobs to obtain meaningful
results. DSPJOBSCDR assists in understanding what is happening to
Job Scheduled jobs.
- DSPRPGCPY
The Display RPG /COPY tool provides two commands. DSPRPGCPY provides
a display or list of the /COPY and/or /INCLUDE statements from one
or more RPG type source members (including RPGLE, RPGMOD etc.) in
one or more source files. An outfile is optional which will allow
further analysis by the DSPRPGCPY2 command which prints or lists the
use of a specific member named on /COPY or /INCLUDE statements. A
query may also be written.
- FNDCMDTXT
The Find Command Text command displays or prints a list of commands
that match a string somewhere in the text description of command
objects such as 'printer'. A file of commands is created by the TAA
install process (using the FNDCMD tool) which contains all commands
on the system except for duplicates in QSYS and the previous release
libraries.
- PROLIB
The Protect Library tool helps prevent specified critical libraries
from an accidental use of CLRLIB or DLTLIB. The tool uses the system
provided command exit program technique. In addition to CLRLIB and
DLTLIB, the TAA Tools CLRLIB2 and DLTLIB2 are also protected. Not
even an *ALLOBJ user will be able to accidentally clear or delete a
protected library.
- RMVLSTCHR
The Remove Last Character command sets the last character in a
variable to blank. It is primarily intended for use when receiving
escape messages that already have a period at the end of the message
text and should be resent using SNDESCMSG (which causes a period to
be added at the end of the text). The message text must be declared
as *CHAR LEN(512).
- RTVDECARA
The Retrieve Decimal Data Area command retrieves the value of a
decimal data area without knowing the length or decimal positions to
a *CHAR LEN(17) variable. A minus sign may precede the value. A
decimal format character will exist if decimal positions are defined
for the data area.
- RTVLSTSPLF
The Retrieve Last Spooled File command retrieves information about
the last spooled file written in the current job. This includes the
name of the spooled file, the spooled file number, and the date and
time of the create.
- RUNIO
The Run I/O command is a testing aid to submit a batch job to
perform a series of writes to a data base file in QTEMP. This can
assist in testing system performance by various tools that need to
work with data base activity.
- SNDESCMSG5
The Send Escape Message 5 command is similar to the TAA SNDESCMSG2
command (part of the SNDESCMSG tool), but also allows a 'stack
counter' to be specified. This allows the escape message to be sent
to a program higher in the stack than the calling program. The
QMHSNDPGM API is used.
Enhancements
- CAPNETA
The text description of the NETWRKATTR data area in TAASECURE is
updated with the current date each time CAPNETA is run.
- CHGOBJAUT
A new parameter has been added to allow deletion.
- CHKCMDDFT
The command has been reworked to account for proxy commands and
commands that cannot be checked are flagged.
- CHKDBFMBR
The text of some escape messages has been improved.
- CHKTGTRLS
The TGTRLS parameter now supports the current release.
- CVTCMDA
A new field has been added to the outfile for the target library
when a proxy command is found.
- CVTIFSAUT
Up to 10 subdirectories may now be omitted.
- DLTOLDQRPL
Additional object types are now supported.
- DSPDBFREL
New options have been added to the display for DSPFMT and DSPOBJD2.
- LOCKMSG
A new alternative program has been added to allow a batch program to
send a message to the submitter of the job when a locked record is
encountered.
- PRINT
A new ACTION value (*OP2) allows the spooled file to be placed in a
HOLD(*YES) status to allow program control of whether the file is
released.
- PRTLMTCMD
Proxy commands that are limited are now identified along with the
actual command that is used.
- RTVAPPVAL
A new return variable exists for the number of keywords defined.
- RTVCMDA
New return variables exist for proxy command information.
- RTVPGMSTK
A new return variable exists for the third program in the stack
prior to the current program.
- SCNCMDKWD
A new parameter has been added to allow the command to be listed if
the keyword exists, does not exist, or both.
- TRNVAL
A second command TRNVAL2 has been added to allow a simple
translation of field to upper case. The CPP XLATE may be called from
a HLL program.
- WRKF2
A new option has been added to the display to use STRSEU for the
member that created the file.
Fixes
- CAPSYSINF
The command failed if QTEMP was not on the library list. This has
been corrected.
- CHGIFSOWN
If apostrophes were placed around the object name, an error
occurred. This has been corrected.
- CHGUSRSPC
The VALUE parameter now accepts an expression.
- CHKINACT2
The DSCOPT value in the Application Value CHKINACT2 in TAASECURE was
missing. This has been corrected.
- CPYTOCSV
COLHDG(*FLDNAM) produced blank column headings. This has been
corrected.
- CVTDTAQ
The OUTMBR parameter was not being used and the output always went
to member DTAQP. This has been corrected.
- CVTFRMSPLF
The *PUBLIC authority was not being set to the library create
authority. This has been corrected.
- CVTIFS
When checking for an omit directory, a pointer error occurred if a
directory and not already been processed. This has been corrected.
- CVTIFSOWN
A large number of IFS objects was not handled properly. This has
been corrected.
- CVTIMGCLGE
Only 15 entries were converted. The RPG program has been converted
to RPGLE to allow a larger receiver variable.
- DLTIFS
When DLTDIR(*NO) was specified, an escape message was sent if the
directory was empty. This condition no longer produces an escape
message.
- DUPTAADBF
When a file was duplicated, the *PUBLIC authority was not being set
to the library CRTAUT value. This has been corrected which impacts
several commands.
- DYNMNU
The RU and RD values were not being handled properly and often
resulted in a message stating that the number of menus in the stack
had been exceeded. This has been corrected.
- FNDCMD
The OUTPUT(*PRINT) option failed. In some cases an error occurred
when rolling. These errors have been corrected.
- PRTOWNOBJ
Errors from RTVOBJD such as a locked object are now noted and
processing continues.
- RBLDBF
The re-create of a physical file failed if the file was specified as
WAITRCD(*NOMAX). The re-create of a logical file failed if the file
was specified as FRCACCPTH(*YES). The files in TAARBLLIB did not
have a size of *NOMAX. These errors have been corrected.
- RPLMOD
C modules are now supported correctly.
- RPLPGM
The current library is changed to the source members library to
increase the odds that a non-library-qualified /COPY statement will
find the right source member. 21 character qualified module or
service programs are now handled correctly.
- RTVCALLR
If the program that invoked RTVCALLR was an ILE program, the name of
the ILE program was returned instead of the previous program. This
has been corrected.
- RTVHOLIDAY
*NEWYEARS was not handled. This has been corrected.
- SAVSNDM
The RSTSNDM command was created with the wrong CPP name. This has
been corrected.
- SCNCMDKWD
If a single member was requested, the command failed. This has been
corrected.
- ZIP
The TAAIFSZR2 command was left out of the create process. This has
been corrected.
Incompatibilities
- CVTCMDA
The library qualifier for the CMD parameter has been changed from
*USRLIBL to *LIBL.
- DLTIFS
If DLTDIR(*NO) was specified and the directory was empty an escape
message was issued. This is no longer considered an error condition.
- DUPTAADBF
When an object was duplicated to a library, the library CRTAUT
authority was not being used for the *PUBLIC user. This has been
corrected and impacts several commands which create outfiles from
TAA commands.. Other commands that create outfiles without the use
of DUPTAADBF have also been changed. In many cases, the outfile is
created in QTEMP and the *PUBLIC user does not have access.
2010-07-15 (R46)
New
- CHKJOBFNC
The Check Job Function command checks for an active job having a
specific Function type-description as seen with WRKACTJOB such as
'PGM-xxx'. Multiple jobs may satisfy the request. A job name is
required. Both the Function type and the Function description are
optional.
- CHKOWNCHG
The Check Owner Change command compares the current owner of one or
more objects to the owner that created the object and displays a
listing. Those objects with the same owner are bypassed. Options
exist to process only those owned by a named user or created by a
named user.
- CPYTOCSV
The Copy to CSV command copies from an externally described data
base file to a stream file and adds delimiters. The intent is to
make a stream file for a spread sheet processor. Options exist to
add delimiters at the end of fields, surround fields with quotes,
and to include column headings.
- CVTOBJD5
The Convert Object Description 5 command provides an outfile for
most of the fields created by DSPOBJD and adds large fields for the
object and save size values to allow for 15 and 20 digit fields.
Edited values are also provided as separate fields. This provides a
simple means of working with large sizes. The model file is TAAOBLZP
with a format name of QLIDOBJD.
- CVTPGMA2
The Convert Program Attributes 2 command converts program object
(*PGM) information to an outfile with one record per program. This
includes module information for up to 100 modules which is written
as an array. This allows simple processing of programs that are made
up of multiple modules. The same information as available with
CVTPGMA plus the module information is output by CVTPGMA2.
- DSPDEPLGL
The Display Dependent Logical command provides a display of the
dependent logical files of a physical file. A physical file must be
specified for the FILE parameter. An option exists from the display
to access other options such as the access path information.
- DSPLSTOBJ
The Display Last Object command displays information about the last
object name of a generic group of objects. The default is for all
object types. If the same name exists for different object types,
the last object type (per system order) determines the object that
is displayed. If you are naming objects using a generic technique,
DSPLSTOBJ can assist in providing information about the last name
assigned.
- DSPUSRCMD
The Display User Commands command displays the audit records for
commands run by a user that is specified with CHGUSRAUD
AUDLVL(*CMD). DSPUSRCMD is intended for use on critical security
profiles such as QSECOFR and QSRV to allow a review of the commands
that were entered. The Journal Code T (Audit) records with an Entry
Type of CD (command was run) are processed using the CPYAUDJRNE
outfile.
- DTAARAARC
The Data Area Archive provides online save files for specified data
areas. Multiple versions may exist for each data area. The DTAARAARC
tool is not intended to replace normal backup, but rather to allow a
quick review of a previous value. A typical use would be to restore
the object to a different library to allow a review. You can also
restore from the online save files. Several commands are provided.
- RMVMSGQMS2
Remove Message Queue Messages 2 command allows a removal from one,
generic, or all message queues for messages that are past a
retention date. The default is to bypass any message queues with a
name beginning with Q in a library beginning with Q. Other message
queues may be specifically bypassed.
- RMVQSYSMSG
The Remove QSYSMSG Messages tool allows both removal and archiving
of messages from the QSYSMSG system message queue. Removal is done
based on the number of days to retain the messages. Archiving is
optional and provides for the QSYSMSGP file in QGPL. If archiving is
used, all new messages (not previously archived) are copied to
QSYSMSGP.
- RNMIFSPGP
The Rename Primary Group Profile command uses the CHGPGP command to
rename the Primary Group Profile of the objects for a user. The To
user becomes the new Primary Group Profile. The default is *CHECK
meaning no changes would occur and a listing of the objects that
would be changed is output. *CHANGE may be specified to change the
Primary Group Profile attribute.
- RNMOBJPGP
The Rename Object Primary Group Profile command sets the PGP
attribute of one or more objects to a new user profile. The PGP
attribute is set by the CHGOBJPGP command. The default for RNMOBJPGP
is for ACTION(*CHECK) which causes a listing of what would be
changed. ACTION(*CHANGE) should be specified to change the attribute
(set it to the new user profile).
- RPTCMD
The Repeat Command command is primarily a testing aid and allows a
command to repeated between 1 and 99999 times. RPTCMD can be helpful
when stress testing a function.
- RTVLSTOBJ
The Retrieve Last Object command retrieves the last name of a
generic name by object type. If you are naming objects using a
generic technique, RTVLSTOBJ can assist in determining the last name
assigned.
- RTVNXTID
The Retrieve Next ID command is designed to return the next ID in a
sequence. For example, if the last ID input is ABC, the next ID that
would be returned is ABD. This allows the assigning of names based
on the last ID that was used. This could be used for object or
member names or for field names in a data base file. Numbers in the
ID are optional.
- RVKIFSPGP
The Revoke IFS Primary Group Profile command sets the Primary Group
Profile to *NONE for a specific user. This allows some cleanup of
the IFS objects. The command defaults to '*CHECK' and provides a
listing of what would be changed if '*REVOKE' had been specified.
- RVKOBJPGP
The Revoke Object Primary Group Profile command sets the PGP
attribute of one or more objects to *NONE. The PGP attribute is set
by the CHGOBJPGP command. The default for RVKOBJPGP is for
ACTION(*CHECK) which causes a listing of what would be changed.
ACTION(*REVOKE) should be specified to revoke the attribute (set it
to *NONE).
- SYSACT
The System Activity tool is a series of commands that lets you
capture and work with the data produced by the WRKSYSACT system
command. This provides performance information for jobs/tasks that
have occurred during one or more intervals. The SYSACT tool can be
helpful in reviewing performance characteristics such as CPU usage,
I/O counts and a breakdown of reads/writes for data base and
non-data base activity.
Enhancements
- CHKTAAOUTF
A parameter has been added to allow checking an individual outfile.
- CPYTOCSV
A new parameter STMFCCSID has been added to allow transformation of
the data as written to the stream file.
- CRTDBFJRN
A new parameter has been added and defaults to allow the
initialization of the DL (delete after image) record if
IMAGES(*AFTER) is specified for the journaled file. No change occurs
to the DL entries if IMAGES(*BOTH) is specified for the journaled
file. If IMAGES(*AFTER) is specified for the journaled file, the new
parameter default allows programs that are processing all entry
types to have valid data in decimal fields. Specifying
INZDLTDFT(*NO) generates the prior option where the DL entries
appear as all blank values.
- CVTJOBPERF
A new parameter has been added for job number.
- DSPACCPTH
The format name has been added to the display.
- DSPMBRCPC
New parameters exist to allow an escape message if any members are
flagged and to specify your own value for what a *NOMAX size means.
- DSPQHST
The output listing now ends at 1320 for easier reading and
additional lines are output if non-blank.
- DSPTOOLCMD
A new option exists to access the command help text.
- ENDDUPJOB
A new parameter has been added to allow the deletion of the job log
if the job is complete and the job log is on the output queue. This
now allows ENDDUPJOB to clean up all duplicate jobs and delete all
job logs regardless of status.
- MTNJRN
New parameters have been added to allow control of the DLTJRNRCV
DLTOPT parameter.
- PRTPRTACG
A sequence parameter has been added.
- RNMUSRPRF
The rename of IFS object PGP (Primary Group Profile) is now
included. A new option has been added to disable and retain the old
profile.
- RPLOBJ
A TGTRLS parameter has been added and also to RPLMOD, RPLGENPGM, and
RPLPGM. The RPLOBJ OBJTYPE parameter supports a new value *PGMMOD to
allow only *MODULE and *PGM objects to be created.
- RTVJOBA2
The current user return variable is now supported on RTVJOBA2.
- RTVJOBSTS
The JOB parameter now supports a generic job and generic user name.
A new parameter has been added to allow selection on the 'current
user' profile.
- RTVOBJD3
A new parameter has been added for the return object type.
- RTVSMTPA
An additional command (RTVSMTPA2) has been added to allow a 2 part
input of an ID and address.
- RUNCPU
A new parameter has been added to allow a burst of CPU activity on a
periodic basis.
- SCNSRC
The file and library text have been added to the output.
- SPLSTO
When PRTSPLSTO is used, the SCHEDULE parameter is now set to
*FILEEND. This avoids the problem caused by the original spooled
file set to *JOBEND with a status of CLO. The new spooled file will
have a status of RDY.
- WHOME
The 'current user' information is now displayed.
- WRKOBJ2
A new parameter has been added for OBJATR.
Fixes
- Install
The CHKTAAOUTF command is now run within the install job to avoid
locking problems.
The INZPWD2 *USRSPC object was not being installed. This has been
corrected.
- APYRMTJRN
If and ENDAPYRMT was issued without any journal entries applied, the
batch job failed with a missing pointer. This has been corrected.
- CLRLIB2
The command was allowed on a library owned by system provided
profile. This is now prevented unless the owner is QPGMR.
- CMPDBF
If the two files did not have the same format an error occurred. The
same format is now required.
- CMPLIB
The same named file with different formats caused an error. These
files are now flagged and bypassed. Other errors from CMPDBF are
flagged and bypassed.
- CMPSRC2
An internal change has been made to use the TAAPRT1 printer file
instead of QPRINT to avoid conflicts.
- CRTDBFJRN
An internal change has been made in the way CVTDAT converts date
formats to allow more international usage. The format used for
*TYPE1 was incorrect and has been fixed.
- CVTIFSOWN
Several corrections were made to account for errors returned by the
internal use of RTVIFSED. A new outfile field was added describing
that errors occurred.
- DLTDLUSPLF
The command failed in an output queue was deleted during processing.
This has been corrected.
- DLTIFS
The command was not deleting an empty directory. This has been
corrected.
- DLTLIB2
The command was allowed on a library owned by system provided
profile. This is now prevented unless the owner is QPGMR.
- DLTOBJ2
No space was left between the object types if multiples were
requested causing an error. This has been corrected.
- DSPMBRCPC
The size for a *NOMAX record file is 4GB rather than the 2GB number
described with the tool. The value has been changed and a new option
added to allow a user defined value for a comparison when *NOMAX is
specified.
- DSPOBJLCK
The size of the internal array has been increased from 3000 to 9999.
The sub program handling member locks was also changed.
- ENDDUPJOB
If a job of the same name has been completed, all spooled files
including the job log will be deleted if SPLFILE(*YES) is specified.
- ENDJOB2
The LOGLMT parameter was mishandled for the *SAME value causing the
job log of an active job to be deleted. This has been corrected.
- FTP2
The SBMFTP2 command failed on a password containing expression
characters. The error handling was case sensitive. ESPV and some
unknown strings were causing errors. These errors have been
corrected.
- JOBACT
If the RDDBR command failed for other than end of file, the
STRACTJOB command just delays and tries again.
- PRTACG
The values for STRDATE of *FIRST and *TODAY were not handled
properly. This has been corrected.
- PRTLMTCMD
The internal code has been reworked to avoid some potential
problems. The V6R1 use of the command aborted on objects that did
not exist. This is monitored for now and bypassed.
- RSTAUTL
The GRTAUTL command now sets the internal file to *NOMAX.
- RTVCTLASC2
Additional MONMSG commands have been added for MCH3601.
- RTVJOBA2
Additional MONMSG commands have been added for cases where the job
no longer exists and removal of certain MCH3601 messages has been
used. If the job was not active, some information was not returned
properly such as Function. This has been corrected.
- RTVJOBSTS
The JOBLIST parameter was not returned correctly in all cases. This
has been corrected.
- RTVOBJD3
The command provided an error when only one object existed and
OBJTYPE(*ALL) was used. This has been corrected.
- RTVRPGFLD
A + symbol in the D spec To/Length field caused a failure. This has
been corrected.
- RVKIFSAUT
Blank lines have been eliminated before *DIR objects which caused
confusion when PRTPUBLIC(*DUP) was specified.
- SPLSTO
The change that was made in the April 15, 2010 version worked for
*AUTO Spool Stores, but failed for *MANUAL types attempting to
update a user space that did not exist. This has been corrected. The
PRTSPLSTO command now uses SCHEDULE(*FILEEND) to allow printing
before the job is ended.
- WRKASP
The numbers shown as MB (megabytes) should be M (millions of bytes).
The same error occurred on DSPASPA2. The displays have been
corrected.
Incompatibilities
- CMPSRC2
The internal print file has been changed from QPRINT to TAAPRT1.
This should have no impact unless you are doing an OVRPRTF to the
name QPRINT.
- CRTDBFJRN
The command now defaults to provide initialized values in the user
fields. for the DL (deleted after image) entry types if the
journaled file is specified as IMAGES(*AFTER). No change occurs if
IMAGES(*BOTH) is specified for the journaled file. Prior to this,
the user fields were filled with blanks as taken from the JOESD
field of the DL journal entries. Specifying INZDLTDFT(*NO) will
retain the blank values.
- RUNCPU
The command now defaults to use the QSYSNOMAX job queue.
2010-04-15 (R45)
New
- CHKTAACHG
The Check TAA Changes command helps provide an understanding of
potential incompatibilities when moving to a new update or version
of the TAA Productivity Tools. The tool is run automatically at the
time of install using the last used date of the previous TAA
commands and a listing is output. The information may not be 100%
complete, but should provide a review of what you should consider.
- CHKTAAOUTF
The Check TAA Outfiles command checks for any existing TAA outfile
names to determine if the level ID is the same as that used by the
current tool. The command is run automatically when the TAA
Productivity Tools are installed and may also be run at any time.
The output listing describes outfiles that may need to be deleted
for successful tool use.
- CLCDATTIM2
The Calculate Date/Time 2 command returns the difference in terms of
number of minutes (an optionally the number of seconds) between a
From date/time and a To date/time. CLCDATTIM2 may be useful when
determining time differences.
- CMPLIBFMT
The Compare Library Format command compares one or more physical
files in one library to the same file names in another library. The
comparison is done for the number of fields, the record length, and
the level ID. This can assist in ensuring files that are intended to
match have the same format in different libraries.
- CPYDBFDAT
The Copy Data Base Date command copies records in a data base file
based on a comparison of a field value and a specified date and
operator. Different date formats are valid for character, zoned,
packed, date, or time stamp fields.
- CPYRFMT
The Copy and Reformat command provides better reformatting
capability than the system CPYF command which supports only *MAP and
*DROP. In addition to *MAP and *DROP functions, CPYRFMT allows
renaming of a field. The To file must exist.
- CVTIFSAUT2
The Convert IFS Authority 2 command converts IFS authorities for a
single user to an outfile named IFSAUT2P. This allows simplified
processing of user authorities. The model file is TAAIFTWP with a
format name of IFSAUT2PR.
- CVTLIBAUT
The Convert Library Authorizations command converts the object
authority information of all objects within a library and the
library object to an outfile. The system command DSPOBJAUT operates
on only a single object. The outfile name is OBJAUTP. The model file
is QAOBJAUT in QSYS with a format name of QSYDSAUT.
- CVTLIBAUT2
The Convert Library Authority 2 command converts the authorities of
users to library objects (not the objects within a library) to an
outfile. The DSPOBJAUT command operates on only a single object. The
outfile name is OBJAUTP. The model file is QAOBJAUT in QSYS with a
format name of QSYDSAUT.
- CVTOBJD4
The Convert Object Description 4 command creates an outfile of
object descriptions based on the DSPOBJD V5R3 outfile format. This
allows a program which uses the outfile that is created on a more
current release to be transferred to a prior release and operate
successfully. The V5R3 format is created using the QUSLOBJ API and
has a format name of QLIDOBJD.
- CVTSFWRSC
The Convert Software Resources command provides a simpler outfile to
work with than the system DSPSFWRSC command. Only the data that
appears on the DSPSFWRSC OUTPUT(*PRINT) listing is converted to the
SFWRSCP outfile. The model file is TAASYTXP with a record format
name of SFWRSCR. Because the listing must be read by CPYSPLF, only
the lower and upper case English language versions of DSPSFWRSC are
supported.
- CVTTIMSEC
The Convert Time to Seconds command converts a time value (HHMMSS)
to a return parameter containing the number of seconds prior to
midnight. For example, if the value is 030000 (3:00 AM), the return
seconds would be (3600 x 3) or 10,800. CVTTIMSEC may be helpful when
dealing with time values.
- DLTDBFDAT
The Delete Data Base Date command deletes (or checks for deletion)
records from a data base file based on a comparison of a field value
and a specified date and operator. Different date formats are valid
for character, zoned, packed, date, or time stamp fields. DLTDBFDAT
can assist in cleaning up files.
- DSPACGCDE
The Display Job Accounting Codes command displays a list of job
accounting codes in code sequence from both User Profiles and Job
Descriptions. This simplifies understanding what Job Accounting
Codes exist and where they are defined.
- DSPJOBPERF
The Display Job Performance command lists job performance
information for the current job. The RESJOBPERF command (part of the
JOBINF tool) should first be used to begin capturing the
information. After some commands are entered, DSPJOBPERF may then by
used to display the information.
- DSPMSGUSE2
The Display Message Use 2 command reads the outfile created by the
SCNEXTMSGF TAA Tool and creates a listing of the message ID and the
command name that sends the message if it is known. Only system
commands that send escape messages can be identified. Diagnostic
messages and messages from APIs cannot be identified.
- DSPSUMJOBQ
The Display Summary of Job Queue command provides a summary of a job
queue by Status and Job Priority. One or both of the summaries may
be listed along with an optional line for each job. DSPSUMJOBQ can
help determine how many jobs exist for each type.
- DSPSUMOUTQ
The Display Summary of Output Queue command provides a summary of an
output queue by Status, Form Type, and User Data. One or all of the
summaries may be listed along with an optional line for each spooled
file. DSPSUMOUTQ can help determine how much printing must occur for
each type.
- DSPUSRSTG
The Display User Storage command provides a display or listing with
one line per user of the number of objects owned and the total
storage used. One, generic, or all users may be requested along with
an omit list. The number of programs, files, and other objects is
also shown.
- JOBINF
The Job Information tool provides commands that allow you to create
a record when a job begins and ends. The information that is
captured includes how and when the job started and a summary of
performance information when the job ended. The STRJOBINF and
ENDJOBINF commands must be included in the job.
- RNMIFSAUT
The Rename IFS Authorities command allows you to change the
authorities from one user to another for IFS objects. The default is
for ACTION(*CHECK) which will not cause any changes, but a listing
is produced describing the changes that would occur. Two exceptions
exist that will prevent a change 1) if the user is the owner of an
object, or 2) if the user is the Primary Group Profile of the
object.
- RTVJOBPERF
The Retrieve Job Performance command retrieves performance
information about the current job. The system keeps statistics for
each job which are retrieved using the API QUSRJOBI. A 'reset' of
the statistics must first be used for the job by RESJOBPERF or
RTVJOBPERF RESET(*YES). Following the running of normal commands,
RTVJOBPERF RESET(*NO) may then be used to retrieve the performance
information that has occurred since the last 'reset'.
- RTVTCPSTKS
The Retrieve TCP Stack Status command retrieves TCP information for
IPv4 and IPv6. Status information such as whether TCP is active or
inactive is available for both IPv4 and IPv6. Starting and ending
information is also available for IPv4.
- RVKIFSAUT
The Revoke IFS Authority command revokes the authorities of a
specified user to IFS objects. The default is to 'check' rather than
'revoke'. A listing is produced describing the results. The
authority is not revoked if the user is the owner of the object or
if the user is the Primary Group Profile. If the user is authorized
via an Authorization List, the Authorization List is not changed.
Enhancements
- CHKDBFMBR
New parameters have been added for record length, number of fields,
and level ID.
- CHKGRPPRF
The tool has been reworked to provide better performance.
- CMPSYSVAL
A specific comparison of the values for QAUDLVL, QAUDLVL2, and
QPWDRULES is now made.
- CRTDBFJRN
The command now supports an OUTFILFMT parameter to allow *TYPE1 ...
*TYPE5 formats of the journal information.
- CVTWRKSPLF
The tool has been reworked to use an open list API (provides a
significant increase in the number of spooled files that can be
processed), additional fields exist in the outfile, and the
performance has been improved. The PRTDEV parameter which was used
to determine the output queue has been dropped.
- DLTUSRPRF2
A new option has been added to allow the deletion of user owned
spooled files. These are not deleted by the system DLTUSRPRF
command.
- DSPTAPSIZ
Additional information has been added such as the volume ID and
owner.
- RMVOLDMSG
The days parameter max value has been increased to 999.
- RNMUSRPRF
IFS authorities are now renamed to the new user.
- RTVGENOBJ
The OBJ parameter now supports *ALLUSR, *USRLIBL, or *ALL as a
qualified name.
- RTVIPLA
New parameters have been added for DSPSTS, STRTCP, and SPLRCV.
- RTVJOBSTRA
A new parameter has been added for Job Queue priority.
- RTVJOBSTS
The job name and user name now support generic values.
- RTVSYSD
A new parameter has been added for the LIC release.
- RVKDUPAUT
The OBJ parameter now supports a library value of *ALL
- SCNEXTMSGF
An outfile option has been added. See the new tool DSPMSGUSE2 for
how to list the outfile along with the command names (if they can be
found) for the associated message IDs.
- SCNSRC
An new parameter has been added to allow a blank to be added at the
end of each argument. The same parameter has been added to
SCNALLSRC, SCNGENSRC, and SCNSRC2.
- WRKJOBSTS
The F6 key is now available to DSPMSG MSGQ(QSYSOPR) MSGTYPE(*INQ).
Fixes
- AUDLOG
The DSPAUDLOG Option 7 failed in some cases. This has been
corrected.
- CHKINACT
In some cases if a job was no longer active the command failed. This
is now monitored for and the job is ignored.
- CLRLIB2
If an object was locked, the command failed. If an error occurred
prior to resetting the job's inquiry message attribute, the command
failed. A new test has been added. These errors have been corrected.
- CPYFRMCSV
An extra comma was output when the character immediately preceding
the delimiter was a comma. This has been corrected.
- CPYFRMCSV2
The command failed attempting to copy to the QTEMP TAATMPFILE file
which had just been deleted. This has been corrected.
- CVTLINETH
The TAATMPOBJ file was created in the OUTLIB instead of QTEMP. The
same error occurred for CVTCTLASC, CVTCTLHOST, CVTCTLVWS, CVTCTLNET,
CVTCTLLWS, CVTLINPPP, CVTLINSDLC, CVTLINASC, and CVTTIMZOND. The
commands worked correctly when OUTLIB(QTEMP) was used. These errors
have been corrected.
- CVTQHST
The QHSTP file is now set for *NOMAX records.
- CVTSYSVAL
The QAUDLVL value now fills the SYCURL field to allow a large list
of entries.
- CVTVOLSTAT
A default tape size of 1/4 is now used.
- CVTWRKSPLF
An open list API is now used to allow a much larger number of
spooled files to be created and performance has been improved.
- DLTDEPLGL
If no logical files exist, the command now ends with a completion
message instead of the escape message CPF3220.
- DSPJOBSTRA
The command failed if displaying the current job. This has been
corrected.
- DSPOBJLCK
The size of the internal array for number of locks has been
increased from 999 to 3000.
- DSPTXT
The use of F6 for was failing as the TAAPRT1 file was already open
and was not correctly handling the end of data. This impacted tools
such as DSPMOON, DSPUSAHST, DSPUSAPRES, and DSPVTPRSC.
- DYNMNU
The test for command line was not checking for *NONE in the menu
record. The indication that this occurs is that the menu is
displayed, but the options entered do not do anything. This has been
corrected.
- EDTDBF
The handling of variable length fields caused the field to contain
blanks. This has been corrected.
- RMVMSGQMSG
The sub tool CVTMSGQ2 is invoked via QCMDEXC and the library is now
qualified.
- RNMUSRPRF
The internal DLTUSRPRF command now specifies the PGPOPT keyword to
change any Primary Group Profiles specified for the old user to the
new user.
- RTVJOBA2
The CPF3C55 message for job not active has been added to the list
that returns TAA9893.
- RVKDUPAUT
Objects which are locked are now bypassed and a diagnostic message
is sent.
- SAVALLCHG2
The build up of the command had 2 uses of the ACCPTH parameter. This
has been corrected.
- SAVAUTL
The AUTLOBJ outfile is now set to *NOMAX.
- SCNEXTMSGF
The scan value is now folded to upper case before scanning.
- SNDIFSMAIL
The escape message from CHKDLO was appearing after the function was
completed. This has been corrected.
- SPLSTO
Because the SPLSTO *USRSPC is updated by the use of of a pointer and
not via an API, any changes were not picked up by a mirroring
technique. The User Space is now updated by an API to allow a
mirroring solution to work properly.
- UPDFLD
A selection of *BLANKS, caused all fields to be updated. This has
been corrected.
Incompatibilities
- CMPDBFFMT
The escape message sent if mismatches occur is now TAA9891 instead
of CPF9898.
- CVTWRKSPLF
The tool has been reworked to use a different API which will provide
better performance and a significant increase in the number of
spooled files that can be processed. The PRTDEV parameter which was
used to determine the output queue has been dropped.
- DLTDEPLGL
If no dependent logical files exist, the command now ends with a
completion message instead of the escape message CPF3220.
- DLTOBJ
The system added a DLTOBJ command in QSYS. The TAA tool has been
renamed to DLTOBJ2. Both commands support the basic parameters of a
generic object name, a library, and a type. There are differences in
the additional parameters and the TAA version supports a list for
object type.
- SCNSPLF2
Since the CVTWRKSPLF command dropped the PRTDEV parameter, it has
also been dropped from SCNSPLF2 which uses CVTWRKSPLF.
- WRKSPLF2
Since the CVTWRKSPLF command dropped the PRTDEV parameter, it has
also been dropped from WRKSPLF2 which uses CVTWRKSPLF.
2010-01-15 (R44)
New
- CHGRPGCPY
The Change RPG /COPY (CHGRPGCPY) command allows changes to /COPY
statements in RPG for one, generic, or all members of a source file.
The CHGRPGCPY2 exists for RPGLE source which also handles /INCLUDE.
The default is OPTION(*CHECK) which means no changes are made and
the listing describes what changes would be made. Selection criteria
exists for the file, library, or member names in the existing /COPY
statement.
- CHKVAL
The Check Value command is intended for the case where the user
inputs a value to a CL program and the value must be validated.
CHKVAL offers several checking options that vary depending on the
type requested. Special values are also supported. Standard error
text may be used to simplify the explanation of any errors.
- CLCTIMZOND
The Calculate Time Zone Difference command returns the number of
minutes difference between two time zones. The time zone names as
used by WRKTIMZON must be input or special values such as *PACIFIC.
Daylight savings time is considered. An optional return value
describes the difference in HH:MM format. A minus value may be
returned.
- CMPALLSRC
The Compare All Source command compares one, all, or generic source
members in one or more source files in a library to the same file
and members in a different library. A listing is produced for each
file and the members. If the corresponding member does not exist or
the data does not match, the member is flagged. An option exists for
a detail comparison of unmatched members.
- CPYNONGEN
The Copy Non Generic command copies records from one file/member to
another and bypasses the records containing a list of generic values
for a named field. This allows 'all but generic xxx' to be copied.
Most queries do not support a selection by '*NE a generic value'.
Using CPYNONGEN allows a subset file to be created which can then be
queried.
- CVTIP6DEV
The Convert IPv6 Device command converts the IP version 6 device
information to the IP6DEVP outfile in a named library. TCP must be
active. Only TCP/IPv6 network interfaces are supported. One record
is written for each IP device. The API QtocLstNetIfc is used. For a
description of the field values in the outfile, refer to the API
documentation for format NIFC0200.
- CVTSRCMBR
The Convert Source Member command converts source that exceeds 70
columns of data to a format not exceeding 70 columns. This allows a
tool such as EDTSRC to work with previously created DDS source such
as CL or DDS. The type of source must be named (CL, CMD, DDS, or
TXT). Any non supported source types are flagged.
- DSPCLPSRC
The Display CLP Source command displays or lists the source for a
CLP type program (CLP, CLP38 and CLLE). If the source does not exist
for a CLP or CLP38 program (non-TAA), a prompt occurs asking if
RTVCLSRC should be used and a display occurs after retrieval. If a
TAA program is specified and the user is authorized to the TAASRCACC
Authorization List, the source in the TAA Archive is displayed.
- DSPCMDSRC
The Display Command Source command displays or lists the command
source for a command. If the source does not exist for a non-TAA
command, a prompt occurs asking if RTVCMDSRC should be used and a
display occurs after retrieval. If a TAA command is specified and
the user is authorized to the TAASRCACC Authorization List, the
source in the TAA Archive is displayed.
- DSPDSTDAT
The Display DST (Daylight Savings Time) Date command displays or
lists the start and end date/times for daylight savings time for a
time zone in a specific year. The system support for Time Zone
Descriptions does not include actual dates of change.
- DSPIFSAUD
The Display IFS Auditing command displays the auditing attribute of
IFS objects. Selection may be made on the type of auditing including
*NONE. DSPIFSAUD assists in understanding what is being audited. To
specify auditing for an IFS object, use CHGAUD.
- DSPTAANAM
The Display TAA Name command allows input of 4 characters for a TAA
ID such as SRCF and sends a completion message with the tool name
and description. This can simplify determining what tool is being
used when only an object name is known.
- DSPTIMZONT
The Display Time Zone Time command displays or lists the date and
time for a specified time zone. The day of week and offset from GMT
are also shown. Daylight savings time (DST) is considered if the
time zone supports DST and the current date/time is within the DST
start and end date/time.
- OPNSPLF
The Open Spooled File command is a testing aid. It allows a spooled
file to be opened with a specific name and remain open. The intent
of OPNSPLF is to allow other functions to test how they operate on
an opened spooled file.
- RTVDSTDAT
The Retrieve DST (Daylight Savings Time) Date command retrieves the
actual dates that daylight savings time will begin and end for a
Time Zone Description in a specific year. The system support for
Time Zone Descriptions does not include actual dates of change. The
TAA9893 escape message is sent if the Time Zone Description does not
support daylight savings time.
- RTVTIMZONT
The Retrieve Time Zone Time command retrieves the current date and
time for a specified time zone. The day of week and offset from GMT
may also be retrieved. Daylight savings time (DST) is considered if
the time zone supports DST and the current date/time is within the
DST start and end date/time.
- SBMCHKACT
The Submit Check of Active Job command is intended for the case
where a job should either
1. Not run longer than n seconds or
2. Be running after n seconds.
A message is sent to a specified message queue if the status is not
what is requested.
- SCNDBFFLD
The Scan Data Base Field command allows a scan of a field in a data
base file for *EQ, *LE, ... *CT (contains). Up to 3 fields that help
identify the record where a match was found may be listed. SCNDBFFLD
provides a simple query of data.
- SCNDEVDSPA
The Scan Device Display Attributes command scans one, generic, or
all display devices for attribute values. This acts as a simple
query to determine the value of attributes of display devices.
- SCNDEVPRTA
The Scan Device Printer Attributes command scans one, generic, or
all printer devices for attribute values. This acts as a simple
query to determine the value of attributes of printer devices.
- SCNJOBLOG
The Scan Job Log command is intended to 'net out' a job log to allow
a review by selection criteria. It allows a display or listing of a
subset of the messages from a specific job log. The selection of
messages may be done by a list of message IDs, message types,
date/time range, severity, or by scanning the message text.
- UNLOAD
The Unload a Device command provides a simple function to ensure a
device is unloaded. If the command completes successfully and
unloads the device or the device is not in a ready status (the
status if already unloaded), the command completes normally.
Different completion message text describes the condition. The
command may be helpful when several save commands are used in a CL
program and it is not known what the device condition is at the end.
Enhancements
- CHKDBFMBR
MBR(*NONE) may now be specified to check against the file.
- CMPSRC2
A new option has been added to allow a detail comparison of any
members that differ.
- CVTIFS
A new value has been added for 'allow save'. The same value is also
available on RTVIFSED2 and DSPIFS.
- DSPHOLIDAY
An outfile option is now available.
- DSPJOBSTRA
New parameters exist for Status and Duplicate Job Request.
- DSPJRNCDE
A wider window is not provided.
- MOVSPLOUTQ
Spooled files in a HLD status may now be moved.
- PMTFLD
A list of field types may be entered to allow selection of only the
named types.
- RTVDTAQD
A new parameter has been added for 'enforce data queue lock'. The
same value has been added to CVTDTAQA.
- RTVJOBSTS
New values exist for DUPJOBRQS to return the first or last job based
on when the job entered the system. The previous values of *FIRST or
*LAST determine the job to return based on job number.
- RTVRPGFLD
Support of /INCLUDE has been added.
- RTVTIMZOND
A new return parameter has been added for daylight savings shift
time. The same field has been added to the CVTTIMZOND outfile.
- SAVLIBSAVF
New parameters have been added for SPLFDTA, QDTA, and PVTAUT. The
same parameters have been added to SAVALLCHG, SAVALLCHG2, and
SAVCHG23 where applicable.
- SNDSTSMSG
A new parameter has been added to allow the same message text to be
sent to the job log.
Fixes
- AUDLOG
The PRTAUDLOG command failed if many journal type entries were
specified. This has been corrected.
- CHGSRCDAT
In some cases the source change date field was not properly updated.
This has been corrected.
- CHKSAVDEV
An escape message now occurs if CLEAR(*NONE) is specified and
ESCAPE(*YES) if the device description specifies 'unload' on a 'vary
off'. You may change the device description or use ESCAPE(*NO).
- CPYSPLTXT
The internal file TAATMPWRK is now created with SIZE(*NOMAX).
- CVTFD
The TAAFDOUT file was not set to *NOMAX. This has been corrected.
- CVTJOBACG3
If a job was cancelled while on the job queue, the information about
the job that did the cancel instead of the job that was cancelled
was placed in the accounting record. This has been corrected.
- CVTOUTQ
Some error messages referred to CVTIFS. This has been corrected.
- DLTLIB2
The command failed attempting to delete an empty library. This has
been corrected.
- DLTOLDSPLF
The command failed if a generic name was used for bypassing an
output queue. This has been corrected.
- DSAOLDPRF
The command failed if an invalid create date existed. These are now
changed to a date of Oct 01, 1978.
- DSPIFS
The previous change that forced the use of the *TYPE2 format has
been rescinded. Either type may now be used. The OBJNAM and IFDIRE
fields are now translated to upper case before making a comparison.
The SORTBY parameter was not handled correctly and caused an error
when opening TAAIFSAT. This has been corrected.
- DSPIFSED
A blank date caused an error using CVTDAT. This is now bypassed.
- DSPPGMADP2
The check for *ALLOBJ special authority produced an error in all
cases. This has been corrected. The command failed if a program or
service program was allocated. Since no corresponding objects will
be converted for the type within a library, a diagnostic will be
sent and the command will fail when all libraries have been
processed.
- DSPSTGUSE
The flagging calculation was in error. This has been corrected.
- DSPTAPSIZ
The TAP01 device was hard coded by error. There was also problem if
more than one page of output existed from DSPTAP. These problems
have been corrected.
- EDTSRC
The documentation has been updated to indicate that 70 bytes of
source may be edited (not 71).
- JOBACG
The ANZJOBACG command failed if a date was outside the range covered
by CVTDAT. These dates are now bypassed.
- PRTLIBAUT
The command failed for library QSYS when trying to operate on
library QTEMP which is now bypassed. Also changed size of internal
OBJAUTP file to *NOMAX.
- RPLPGM
The library name failed if *CURLIB had been used. This has been
corrected.
- RTVPGMREFL
Incorrect service program information was returned if more than one
service program existed. This has been corrected.
- RTVPRDDSC
Only the last 3 character of the 7 character product ID are now used
to determine the description.
- RTVRPGFLD
If a /COPY was used and the file or member could not be found,
better error messages are now sent describing the error.
- SAVSYSBCH
The internal use of CHKSAVRST caused errors if the system did not
have a upper or lower case English option. New parameters have been
added for CHKSAVRST and PRTSAVLBL to bypass these functions.
An error in the documentation stated that on completion of a save
option that the system restarted the controlling subsystem. This is
incorrect. The controlling subsystem is restarted when the job
running SAVSYSBCH ends thus allowing the POWERDOWN option to be used
before the controlling subsystem is restarted. The documentation has
been corrected.
The same documentation change was made to RCLSTGBCH.
- SNDIFSMAIL
The command failed if TAAFLR did not exist. This is now monitored
for internally.
- SPLSTO
If a spooled file was deleted during an attempt to convert to the
spool store, the command failed. This condition is now bypassed by a
change to CVTFRMSPLF.
- WRTIFS
If a previous caller failed, the open failed on the next attempt.
This has been corrected.
Incompatibilities
- CHKSAVDEV
An escape message now occurs if CLEAR(*NONE) is specified and
ESCAPE(*YES) if the device description specifies 'unload' on a 'vary
off'. You may change the device description or use ESCAPE(*NO).
- DSPJOBSTRA
The default has been changed to display the last job (highest job
number) if a duplicate set of job names exist.
2009-10-15 (R43)
New
- ADDRDBDIR2
The Add Relational Data Base (RDB) command is intended to assist in
moving RDB entries as seen with DSPRDBDIRE to a different system.
You must first capture the RDB entries to an outfile with DSPRDBDIRE
and then move the outfile to the system to be applied to. Duplicate
RDB names are rejected as well as a second version of *LOCAL for the
Remote Location Name.
- ADJAPOST
The Adjust Apostrophes command is designed to adjust the number of
apostrophes in a variable so that the return result is valid for
command processing. ADJAPOST is specifically designed for IFS
processing, but may be used for variables intended for non-IFS use.
- CHKDBFMBR
The Check Data Base File Member command simplifies checking for a
data base file and authority to it. This provides clear messages
when the file or member does not exist, the file is not the
requested file type, or the user does not have the proper
authorization.
- CHKSTDJOBS
The Check Standard Jobs command provides a method of determining if
required system and standard processing jobs are active. CHKSTDJOBS
operates by using the output of the TAA CVTWRKACT command when the
system is known to be in a good state and checking the jobs to see
if they are still active.
- CVTJOBPERF
The Convert Job Performance command converts job performance
information for specified active jobs to an outfile. A reset
capability exists. This provides a simple summary of such things as
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
CPU seconds used, the percentage of CPU seconds used, transaction
|
