AQAB777KJCS+RAHmOboinkvErasRf6uB57uwAj0F65NYwFKkflx9xzvwEnJNmH5wKDdz90PuO6nc/Y1ulVtfTIN9MO5yStdaOLiXdR8u76mH7Vt5YxDbTIQQtZ6WL267sNSXZvB9U9XAqjH457d5AsZIHToh5Gd/TNHzi6UbI6AqhOzKueo=<?xml version="1.0"?>

<!-- *** NOTE: Each ReportNumericId number must match the STDREP_ defined in rptdefs.h *** -->

<AppDef>
	
	<Report ID="STDREP_PANDL_STD" ReportNumericId="0" Name="Profit &amp; Loss Standard">
		<Description>How much money did my company make or lose over a specific period of time?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_pl.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PANDL_STD</ImageName>
	</Report>

	<Report ID="STDREP_PANDL_COMP" ReportNumericId="1" Name="Profit &amp; Loss Prev Year Comparison">
		<Description>Is my company making more money now than for the same period a year ago?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_pl_previous.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PANDL_COMP</ImageName>
	</Report>

	<Report ID="STDREP_PANDL_JOB" ReportNumericId="2" Name="Profit &amp; Loss by Job">
		<Description>How much money is my company making or losing on each job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_pl_byjob.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PANDL_JOB</ImageName>
	</Report>

	<Report ID="STDREP_PANDL_CLASS" ReportNumericId="3" Name="Profit &amp; Loss by Class">
		<Description>How much money did my company make or lose on  each business segment that is tracked through QuickBooks classes?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_pl_byclass.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PANDL_CLASS</ImageName>
	</Report>

	<Report ID="STDREP_PANDL_ITEMIZED" ReportNumericId="4" Name="Profit &amp; Loss Detail">
		<Description>What are the year-to-date transactions (and totals) for each income and expense account, 
			so I can determine what contributed to my company's net profit?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_pl_itemized.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PANDL_ITEMIZED</ImageName>
	</Report>

  <!-- ifdef INTL_AU -->
  <Report ID="STDREP_BS_AUSTD" ReportNumericId="9000" Name="Balance Sheet">
    <Description>What is the value of my company (its assets, liabilities, and equity), showing me the individual balances for each account?</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_balsheet.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_BS_STD</ImageName>
  </Report>

  <Report ID="STDREP_BS_AUCOMP" ReportNumericId="9003" Name="Balance Sheet Prev Year Comparison">
    <Description>How has the value of my company (its assets, liabilities, and equity), changed compared to the same date one year ago?</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_balsheet_comparison.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_BS_COMP</ImageName>
  </Report>

  <Report ID="STDREP_BS_AUSMRY" ReportNumericId="9002" Name="Balance Sheet Summary">
    <Description>What is the value of my company (its assets, liabilities, and equity), showing me the total balance for each type of account?</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_balsheet_summary.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_BS_SMRY</ImageName>
  </Report>

  <Report ID="STDREP_BS_AUITEMIZED" ReportNumericId="9001" Name="Balance Sheet Detail">
    <Description>What is the value of my company (its assets, liabilities, and equity), showing me the transactions and the starting and ending balances for each account?</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_balsheet_itemized.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_BS_ITEMIZED</ImageName>
  </Report>
  
  <!-- else -->
  
  <Report ID="STDREP_BS_STD" ReportNumericId="5" Name="Balance Sheet Standard">
		<Description>What is the value of my company (its assets, liabilities, and equity), showing me the individual balances for each account?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_balsheet.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_BS_STD</ImageName>
	</Report>

  <Report ID="STDREP_BS_COMP" ReportNumericId="6" Name="Balance Sheet Prev Year Comparison">
		<Description>How has the value of my company (its assets, liabilities, and equity), changed compared to the same date one year ago?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_balsheet_comparison.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_BS_COMP</ImageName>
	</Report>

	<Report ID="STDREP_BS_SMRY" ReportNumericId="7" Name="Balance Sheet Summary">
		<Description>What is the value of my company (its assets, liabilities, and equity), showing me the total balance for each type of account?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_balsheet_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_BS_SMRY</ImageName>
	</Report>

	<Report ID="STDREP_BS_ITEMIZED" ReportNumericId="8" Name="Balance Sheet Detail">
		<Description>What is the value of my company (its assets, liabilities, and equity), showing me the transactions and the starting and ending balances for each account?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_balsheet_itemized.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_BS_ITEMIZED</ImageName>
	</Report>
  
<!-- endif -->
  
	<Report ID="STDREP_CASHFLOW_FORECAST" ReportNumericId="9" Name="Cash Flow Forecast">
		<Description>What income and expenses can I anticipate over the next few weeks from receivables, payables, and banking?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_cashflow.html </HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_CASHFLOW_FORECAST</ImageName>
	</Report>



	<Report ID="STDREP_SALES_SMRY" ReportNumericId="10" Name="Sales by Item Summary">
		<Description>For each item or service: how many have been sold, what is the total dollar sales, and what is its percentage of my total sales? 
		Which items and/or services bring in the most/least income?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_sales_item_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_SALES_SMRY</ImageName>
	</Report>



	<Report ID="STDREP_SALES_ITEMIZED" ReportNumericId="11" Name="Sales by Item Detail">
		<Description>What are the sales of each item, broken down by transaction?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_sales_item_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_SALES_ITEMIZED</ImageName>
	</Report>



  <Report ID="STDREP_ARAGING_SMRY" ReportNumericId="12" Name="A/R Aging Summary">
    <Description>How much does each customer owe? How much of each customer's balance is overdue?</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ar_aging_summary.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_ARAGING_SMRY</ImageName>
  </Report>



  	<Report ID="STDREP_ARAGING_DETAIL" ReportNumericId="13" Name="A/R Aging Detail">
		<Description>Which invoices or statement charges are due and overdue?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ar_aging_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_ARAGING_DETAIL</ImageName>
	</Report>

	<Report ID="STDREP_COLLECT" ReportNumericId="14" Name="Collections Report">
		<Description>Which customers are overdue, how much do they owe, and what are their phone numbers?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ar_collections.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_COLLECT</ImageName>
	</Report>



	<Report ID="STDREP_APAGING_SMRY" ReportNumericId="15" Name="A/P Aging Summary">
		<Description>How much does my company owe each supplier? How much of the balance for each supplier is overdue?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ap_aging_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_APAGING_SMRY</ImageName>
	</Report>



	<Report ID="STDREP_APAGING_DETAIL" ReportNumericId="16" Name="A/P Aging Detail">
		<Description>Which bills are due and overdue?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ap_aging_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_APAGING_DETAIL</ImageName>
	</Report>



	<!-- Report ID="STDREP_1099" ReportNumericId="18" Name="1099 Summary">
		<Description>What amounts need to be reported for each supplier that receives a 1099-MISC form? 
			Important: Check this report before you print the forms.</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ap_1099.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_1099</ImageName>
	</Report -->



	<Report ID="STDREP_TRANSBYACCNT" ReportNumericId="19" Name="Transaction Detail by Account">
		<Description>What are the recent transactions (and their subtotals) for each account in my Chart of Accounts?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_trans_detail_acct.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TRANSBYACCNT</ImageName>
	</Report>

	<Report ID="STDREP_TRANSBYCUST" ReportNumericId="20" Name="Transaction List by Customer">
		<Description>What transactions has my company had with each customer?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_trans_customer.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TRANSBYCUST</ImageName>
	</Report>



	<Report ID="STDREP_TRANSBYVENDOR" ReportNumericId="21" Name="Transaction List by Supplier">
		<Description>What transactions has my company had with each supplier?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_trans_vendor.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TRANSBYVENDOR</ImageName>
	</Report>



  <!-- ifdef INTL_AU -->
  <Report ID="STDREP_MISSINGCHECK" ReportNumericId="25" Name="Missing Cheques">
    <Description>
      For a specified account, lists all cheques that have been written so you can check for missing and duplicate cheque numbers.
      You can also use this report to check for duplicate or missing invoices in accounts receivable or payments in a current asset account.
    </Description>
    <!-- else -->
<!--  <Report ID="STDREP_MISSINGCHECK" ReportNumericId="25" Name="Missing Checks">
		<Description>For a specified account, lists all checks that have been written so you can check for missing and duplicate check numbers. 
			You can also use this report to check for duplicate or missing invoices in accounts receivable or payments in a current asset account.</Description> -->
    <!-- endif -->
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_missing_checks.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_MISSINGCHECK</ImageName>
	</Report>


	<Report ID="STDREP_TRIALBAL" ReportNumericId="27" Name="Trial Balance">
		<Description>What is the ending balance for all accounts?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_trial_balance.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TRIALBAL</ImageName>
	</Report>



	<Report ID="STDREP_JOURNAL" ReportNumericId="28" Name="Journal">
		<Description>What are the most recent transactions, in chronological order?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_journal.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_JOURNAL</ImageName>
	</Report>



	<Report ID="STDREP_GRAPHINCEXP" ReportNumericId="29" Name="Income &amp; Expense Graph">
		<Description>How does my company's income compare to expenses? What are the largest sources of income and expenses?</Description>
		<HelpTopic>REPORTS_N.CHM::/graphs_n/graph_incexp.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_GRAPHINCEXP</ImageName>
	</Report>



	<Report ID="STDREP_GRAPHBALSHEET" ReportNumericId="30" Name="Net Worth Graph">
		<Description>How have my company's assets, liabilities, and equity (i.e., its net worth) changed over a specific period of time?</Description>
		<HelpTopic>REPORTS_N.CHM::/graphs_n/graph_networth.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_GRAPHBALSHEET</ImageName>
	</Report>



	<Report ID="STDREP_GRAPHBUDGET" ReportNumericId="31" Name="Budget vs. Actual Graph">
		<Description>Are my company's income and expenses over or under budget?</Description>
		<HelpTopic>REPORTS_N.CHM::/graphs_n/graph_budget.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_GRAPHBUDGET</ImageName>
	</Report>

	<Report ID="STDREP_GRAPHSALESBYITEM" ReportNumericId="32" Name="Sales Graph">
		<Description>Which month has the highest sales revenue? Which items, customers, or sales reps bring in the most income?</Description>
		<HelpTopic>REPORTS_N.CHM::/graphs_n/graph_sales.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_GRAPHSALESBYITEM</ImageName>
	</Report>



	<!-- Report ID="STDREP_1099DETAIL" ReportNumericId="39" Name="1099 Detail">
		<Description>Which supplier transactions are subject to reporting on the 1099-MISC form?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ap_1099_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_1099DETAIL</ImageName>
	</Report -->



	<Report ID="STDREP_GENLEDGER" ReportNumericId="42" Name="General Ledger">
		<Description>What is the recent activity in all my company's accounts, with beginning and ending balances for each account?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ledger.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_GENLEDGER</ImageName>
	</Report>



	<Report ID="STDREP_SALESBYCUSTSMRY" ReportNumericId="43" Name="Sales by Customer Summary">
		<Description>What is the total sales for each customer and job? </Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_sales_cust_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_SALESBYCUSTSMRY</ImageName>
	</Report>



	<Report ID="STDREP_SALESBYCUSTDETAIL" ReportNumericId="44" Name="Sales by Customer Detail">
		<Description>What are the sales to each customer and job, broken down by transaction?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_sales_cust_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_SALESBYCUSTDETAIL</ImageName>
	</Report>



	<Report ID="STDREP_OPENINVOICE" ReportNumericId="45" Name="Open Invoices">
		<Description>Which invoices or statement charges haven't been paid and when are they due?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ar_open_invoice.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_OPENINVOICE</ImageName>
	</Report>



	<Report ID="STDREP_OPENBILL" ReportNumericId="46" Name="Unpaid Bills Detail">
		<Description>How much does my company owe each supplier, and are any payments overdue?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ap_unpaid_bills.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_OPENBILL</ImageName>
	</Report>



	<Report ID="STDREP_SALESBYREPSMRY" ReportNumericId="48" Name="Sales by Rep Summary">
		<Description>What is the total sales for each sales representative?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_sales_rep_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_SALESBYREPSMRY</ImageName>
	</Report>



	<Report ID="STDREP_SALESBYREPDETAIL" ReportNumericId="49" Name="Sales by Rep Detail">
		<Description>Which sales did each sales representative make?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_sales_rep_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_SALESBYREPDETAIL</ImageName>
	</Report>



	<Report ID="STDREP_CUSTBALSMRY" ReportNumericId="50" Name="Customer Balance Summary">
		<Description>How much does each customer owe?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ar_custbal_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_CUSTBALSMRY</ImageName>
	</Report>



	<Report ID="STDREP_VENDBALSMRY" ReportNumericId="51" Name="Supplier Balance Summary">
		<Description>What is my company's current balance with each supplier?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ap_vend_bal_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_VENDBALSMRY</ImageName>
	</Report>



	<Report ID="STDREP_CUSTBALDETAIL" ReportNumericId="52" Name="Customer Balance Detail">
		<Description>What payments and invoices make up each customer's current balance?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ar_custbal_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_CUSTBALDETAIL</ImageName>
	</Report>



	<Report ID="STDREP_VENDBALDETAIL" ReportNumericId="53" Name="Supplier Balance Detail">
		<Description>What transactions make up my company's current balance with each supplier?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ap_vend_bal_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_VENDBALDETAIL</ImageName>
	</Report>



	<Report ID="STDREP_INCCUSTSMRY" ReportNumericId="54" Name="Income by Customer Summary">
		<Description>What is the gross profit (sales minus cost of goods sold) received from each customer?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_pl_cust_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INCCUSTSMRY</ImageName>
	</Report>



	<Report ID="STDREP_INCCUSTDETAIL" ReportNumericId="55" Name="Income by Customer Detail">
		<Description>What is the gross profit (sales minus cost of goods sold), broken down by transaction, received from each customer?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_pl_cust_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INCCUSTDETAIL</ImageName>
	</Report>



	<Report ID="STDREP_EXPVENDSMRY" ReportNumericId="56" Name="Expenses by Supplier Summary">
		<Description>What are my company's total expenses for each supplier?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_pl_vend_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_EXPVENDSMRY</ImageName>
	</Report>



	<Report ID="STDREP_EXPVENDDETAIL" ReportNumericId="57" Name="Expenses by Supplier Detail">
		<Description>What are my company's total expenses, per transaction, for each supplier?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_pl_vend_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_EXPVENDDETAIL</ImageName>
	</Report>



	<Report ID="STDREP_PANDL_YTD" ReportNumericId="76" Name="Profit &amp; Loss YTD Comparison">
    <!-- ifdef INTL_AU -->
    <Description>How do my income and expenses for a recent period of time compare to the entire financial year to date?</Description>
    <!-- else -->
    <!--		<Description>How do my income and expenses for a recent period of time compare to the entire fiscal year to date?</Description> -->
    <!-- endif -->
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_pl_ytd.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PANDL_YTD</ImageName>
	</Report>



	<Report ID="STDREP_AUDITTRAIL" ReportNumericId="84" Name="Audit Trail">
		<Description>What changes affected my company's books during a specified accounting period? Who made the changes?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_audit_trail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_AUDITTRAIL</ImageName>
	</Report>



	<Report ID="STDREP_PURCH_SMRY" ReportNumericId="85" Name="Purchases by Item Summary">
		<Description>For each item or service, how many has my company bought, and what is the total amount spent?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_purch_item_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PURCH_SMRY</ImageName>
	</Report>



	<Report ID="STDREP_PURCH_ITEMIZED" ReportNumericId="86" Name="Purchases by Item Detail">
		<Description>What are my company's total purchases for each item and service, broken down by transaction?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_purch_item_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PURCH_ITEMIZED</ImageName>
	</Report>



	<Report ID="STDREP_PURCHBYVENDSMRY" ReportNumericId="87" Name="Purchases by Supplier Summary">
		<Description>What are my company's total purchases from each supplier?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_purch_vendor_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PURCHBYVENDSMRY</ImageName>
	</Report>



	<Report ID="STDREP_PURCHBYVENDDETAIL" ReportNumericId="88" Name="Purchases by Supplier Detail">
		<Description>What are my company's total purchases, broken down by transaction, from each supplier?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_purch_vendor_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PURCHBYVENDDETAIL</ImageName>
	</Report>



<!-- ifdef INTL_AU -->
	<Report ID="STDREP_INV_STOCKBYITEM" ReportNumericId="89" Name="Inventory Status by Item">
		<Description>What is the detailed information about each inventory item? Includes stock on hand, to show if it's time to reorder.</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_inv_stock_byitem.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INV_STOCKBYITEM</ImageName>
	</Report>
<!-- else -->
  <!-- <Report ID="STDREP_INV_STOCKBYITEM" ReportNumericId="89" Name="Inventory Stock Status by Item"> -->
  <!-- 		<Description>What is the detailed information about each inventory item? Includes stock on hand, to show if it's time to reorder.</Description> -->
  <!-- 		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_inv_stock_byitem.html</HelpTopic> -->
  <!-- 		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INV_STOCKBYITEM</ImageName> -->
  <!-- 	</Report> -->
<!-- endif -->


<!-- ifdef INTL_AU -->
  <Report ID="STDREP_INV_STOCKBYVEND" ReportNumericId="90" Name="Inventory Status by Supplier">
    <Description>
      What is the detailed information about each inventory item, organised by supplier?
      Includes stock on hand, to show if it's time to reorder.
    </Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_inv_stock_byvendor.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INV_STOCKBYVEND</ImageName>
  </Report>
<!-- else -->
  <!-- <Report ID="STDREP_INV_STOCKBYVEND" ReportNumericId="90" Name="Inventory Stock Status by Supplier"> -->
  <!--   <Description>What is the detailed information about each inventory item, organized by supplier? -->
  <!--	  Includes stock on hand, to show if it's time to reorder.</Description> -->
  <!--   <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_inv_stock_byvendor.html</HelpTopic> -->
  <!--   <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INV_STOCKBYVEND</ImageName> -->
  <!-- </Report> -->
<!-- endif -->



  <Report ID="STDREP_INV_VALSMRY" ReportNumericId="92" Name="Inventory Valuation Summary">
		<Description>What is the current asset and retail value of each inventory item?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_inv_value_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INV_VALSMRY</ImageName>
	</Report>



	<Report ID="STDREP_INV_VALDETAIL" ReportNumericId="93" Name="Inventory Valuation Detail">
		<Description>Which transactions have affected the value of my inventory?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_inv_value_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INV_VALDETAIL</ImageName>
	</Report>



<!-- ifdef INTL_AU -->
  <Report ID="STDREP_INV_PHYSWKSHT" ReportNumericId="94" Name="Stock Take Worksheet">
<!-- else -->
  <!-- <Report ID="STDREP_INV_PHYSWKSHT" ReportNumericId="94" Name="Physical Inventory Worksheet"> -->
<!-- endif -->
		<Description>A worksheet that you can use to check your physical inventory against your QuickBooks records.</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_inv_worksheet.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INV_PHYSWKSHT</ImageName>
	</Report>

  <!--INTL_AU Tax detail Report -->
  <Report ID="STDREP_VATDETAIL" ReportNumericId="99" Name="Tax Detail">
    <Description>This is the report for Tax Detail</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_emp_state_taxes.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TAX_DETAIL</ImageName>
  </Report>
  <!-- end INTL_AU Tax Detail Report -->



	<Report ID="STDREP_QBP_SMRY" ReportNumericId="104" Name="Payroll Summary">
<!-- ifdef INTL_AU -->
    <Description>What are the accumulated totals for the payroll items (taxes withheld, etc.) on each employee's recent payments?</Description>
<!-- else -->
 <!--   <Description>What are the accumulated totals for the payroll items (taxes withheld, etc.) on each employee's recent paychecks?</Description> -->
<!-- endif -->
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_emp_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_QBP_SMRY</ImageName>
	</Report>



	<Report ID="STDREP_QBP_LIAB" ReportNumericId="105" Name="Payroll Liability Balances">
		<Description>What payroll-related taxes and fees does my company currently owe to the government and other agencies?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_pitem_liabilities.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_QBP_LIAB</ImageName>
	</Report>



	<Report ID="STDREP_OPENPO" ReportNumericId="112" Name="Open Purchase Orders">
		<Description>For all open purchase orders, what are the supplier name, PO number, amount, order date, and the expected delivery date?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_purch_open_po.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_OPENPO</ImageName>
	</Report>



<!-- ifdef INTL_AU -->
  <Report ID="STDREP_CHECKDETAIL" ReportNumericId="115" Name="Payment Detail">
    <Description>What cheques have been written, including the details of each one?</Description>
<!-- else -->
  <!-- <Report ID="STDREP_CHECKDETAIL" ReportNumericId="115" Name="Check Detail"> -->
		<!-- <Description>What checks have been written, including the details of each one?</Description> -->
<!-- endif -->
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_check_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_CHECKDETAIL</ImageName>
	</Report>



	<Report ID="STDREP_DEPOSITDETAIL" ReportNumericId="116" Name="Deposit Detail">
		<Description>Lists all deposited and undeposited payments, including the customer who made 
			the payment and how much of each payment was included in the deposit.</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_deposit_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_DEPOSITDETAIL</ImageName>
	</Report>



	<Report ID="STDREP_INCOMETAX_SMRY" ReportNumericId="119" Name="Income Tax Summary">
		<Description>Based on tax line assignments, what amounts does my company need to report on its income tax forms?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_tax_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INCOMETAX_SMRY</ImageName>
	</Report>

	
	<Report ID="STDREP_TEJ_TM_EMP" ReportNumericId="120" Name="Time by Name">
		<Description>How much time has each employee (or subcontractor) spent on each job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_time_name.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_TM_EMP</ImageName>
	</Report>
	

	<Report ID="STDREP_TEJ_TM_JOB" ReportNumericId="121" Name="Time by Job Summary">
		<Description>How much time did my company spend on each job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_time_job.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_TM_JOB</ImageName>
	</Report>



	<Report ID="STDREP_TEJ_TM_ITEM" ReportNumericId="122" Name="Time by Item">
		<Description>How much time has my company spent on each service we provide?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_time_item.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_TM_ITEM</ImageName>
	</Report>



	<Report ID="STDREP_TEJ_JOB_PROFIT" ReportNumericId="124" Name="Job Profitability Summary">
		<Description>What total amount has my company made or lost on each job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_tej_jobprofit_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_JOB_PROFIT</ImageName>
	</Report>



	<Report ID="STDREP_TEJ_JOB_PROF_DET" ReportNumericId="125" Name="Job Profitability Detail">
		<Description>For a particular job, what activities have generated the most (and least) profit? You'll be prompted to select the job for which you want to run this report.</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_tej_jobprofit_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_JOB_PROF_DET</ImageName>
	</Report>



	<Report ID="STDREP_TEJ_JOB_EST" ReportNumericId="126" Name="Job Estimates vs. Actuals Summary">
		<Description>How well does my company estimate the costs and revenue for each job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_tej_estimate_vs_actual.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_JOB_EST</ImageName>
	</Report>



	<Report ID="STDREP_TEJ_JOB_EST_DET" ReportNumericId="127" Name="Job Estimates vs. Actuals Detail">
		<Description>How well does my company estimate the costs and revenue for each aspect of a particular job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_tej_estimate_vs_actual_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_JOB_EST_DET</ImageName>
	</Report>



	<Report ID="STDREP_TEJ_ITEM_PROFIT" ReportNumericId="128" Name="Item Profitability">
		<Description>What total amount has my company made or lost on each inventory item, part, service, or expense for which we bill customers?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_tej_item_profitability.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_ITEM_PROFIT</ImageName>
	</Report>



	<Report ID="STDREP_TEJ_ITEM_EST" ReportNumericId="129" Name="Item Estimates vs. Actuals">
		<Description>How well did my company estimate the costs and revenue for each item, part, service, or expense for which we bill customers?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_tej_item_estimate_vs_actual.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_ITEM_EST</ImageName>
	</Report>


	<Report ID="STDREP_TEJ_TM_DETAIL" ReportNumericId="130" Name="Time by Job Detail">
		<Description>How much time did my company spend on each aspect of each job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_time_activity.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_TM_DETAIL</ImageName>
	</Report>

	<Report ID="STDREP_TEJ_PROGRESS_BILLING" ReportNumericId="142" Name="Job Progress Invoices vs. Estimates">
		<Description>For each progress invoice, how much of the estimated amount has been billed?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_tej_progress_invoices.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_PROGRESS_BILLING</ImageName>
	</Report>


	<Report ID="STDREP_TEJ_TMNAME_BILLABLESTATUS" ReportNumericId="143" Name="Billed/Unbilled Hours by Person">
		<Description>How much time has each employee or subcontractor worked?  What is the billable status of that time?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_time_billstat.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_TMNAME_BILLABLESTATUS</ImageName>
	</Report>



	<Report ID="STDREP_TEJ_TMNAMEJOB_BILLABLESTATUS" ReportNumericId="144" Name="Billed/Unbilled Hours by Person and Job">
		<Description>How much time has each employee or subcontractor spent on each job?  What is the billable status of that time?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_time_job_billstat.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_TMNAMEJOB_BILLABLESTATUS</ImageName>
	</Report>

	<Report ID="STDREP_TEJ_TMNAMEITEM_BILLABLESTATUS" ReportNumericId="145" Name="Billed/Unbilled Hours by Person and Activity">
		<Description>How much time has each employee or subcontractor spent on each job and item?  What is the billable status of that time?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_time_item_billstat.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_TMNAMEITEM_BILLABLESTATUS</ImageName>
	</Report>

	<Report ID="STDREP_TEJ_MWD_PROFITABILITY_PRODUCT" ReportNumericId="149" Name="Profitability by Product">
		<Description>Which products are most profitable?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_mwd_profitability_by_product.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_MWD_PROFITABILITY_PRODUCT</ImageName>
	</Report>


	<Report ID="STDREP_TEJ_PROSVC_TMNAMEPROJECT" ReportNumericId="150" Name="Billed/Unbilled Hours by Person and Project">
		<Description>How much time has each employee or subcontractor spent on each project? What is the billable status of that time?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_prof_time_project_billstat.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_PROSVC_TMNAMEPROJECT</ImageName>
	</Report>



	<Report ID="STDREP_BILLEDVSPROPOSAL_PROJECT" ReportNumericId="151" Name="Billed vs. Proposal by Project">
		<Description>How well did estimated income match actual income for each project?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_prof_billed_vs_proposal.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_BILLEDVSPROPOSAL_PROJECT</ImageName>
	</Report>



	<Report ID="STDREP_TEJ_RETAIL_ESTIMATES_BY_CUST" ReportNumericId="152" Name="Estimates by Customer">
		<Description>What outstanding estimates does my company have for each customer?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_rr_est_by_cust.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_RETAIL_ESTIMATES_BY_CUST</ImageName>
	</Report>

	<Report ID="STDREP_TEJ_COSTTOCOMPLETE_SUMMARY" ReportNumericId="153" Name="Cost to Complete by Job Summary">
		<Description>What is the expected cost to complete all of my jobs? How much is each job over or under estimate?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_cost_to_complete_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_COSTTOCOMPLETE_SUMMARY</ImageName>
	</Report>

	<Report ID="STDREP_TEJ_COSTTOCOMPLETE_DETAIL" ReportNumericId="154" Name="Cost to Complete by Job Detail">
		<Description>What is the expected cost to complete a particular job, and what should it cost to complete each item of that job? How much is each item over or under estimate?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_cost_to_complete_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_COSTTOCOMPLETE_DETAIL</ImageName>
	</Report>
	
	<Report ID="STDREP_INCOMETAX_DETAIL" ReportNumericId="201" Name="Income Tax Detail">
		<Description>What transactions make up each amount to be reported on my company's income tax forms?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_tax_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INCOMETAX_DETAIL</ImageName>
	</Report>

  <Report ID="STDREP_AU_PAYROLL_TOTALS_SMRY_RPT" ReportNumericId="9030" Name="Payroll Totals">
    <Description>What are the payroll totals for each employee?</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_emp_withhold.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_EMPLOYEE_WITHHOLDING</ImageName>
  </Report>
  
	<Report ID="STDREP_QBP_EMPJOURNAL" ReportNumericId="202" Name="Employee Earnings Summary">
		<Description>What are the payroll totals</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_emp_journal.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_QBP_EMPJOURNAL</ImageName>
	</Report>



	<Report ID="STDREP_PENDING_SALES" ReportNumericId="203" Name="Pending Sales">
		<Description>Which sales are marked as pending?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_sales_pending.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PENDING_SALES</ImageName>
	</Report>



	<Report ID="STDREP_TRANSBYDATE" ReportNumericId="208" Name="Transaction List by Date">
		<Description>What transactions were entered for a specified period of time?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_trans_date.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TRANSBYDATE</ImageName>
	</Report>



	<Report ID="STDREP_LIST_CUSTOMER_PHONE" ReportNumericId="213" Name="Customer Phone List">
		<Description>What is the phone number for each customer?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_cust_phone.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_CUSTOMER_PHONE</ImageName>
	</Report>



	<Report ID="STDREP_LIST_CUSTOMER_CONTACT" ReportNumericId="214" Name="Customer Contact List">
		<Description>What is the contact information and current balance of each customer?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_cust_contact.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_CUSTOMER_CONTACT</ImageName>
	</Report>



	<Report ID="STDREP_LIST_VENDOR_PHONE" ReportNumericId="215" Name="Supplier Phone List">
		<Description>What is the phone number for each supplier?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_vend_phone.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_VENDOR_PHONE</ImageName>
	</Report>


	<Report ID="STDREP_LIST_VENDOR_CONTACT" ReportNumericId="216" Name="Supplier Contact List">
		<Description>What is the contact information and current balance for each supplier?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_vend_contact.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_VENDOR_CONTACT</ImageName>
	</Report>


	<Report ID="STDREP_LIST_EMPLOYEE_CONTACT" ReportNumericId="218" Name="Employee Contact List">
  <!-- ifdef INTL_AU -->
     <Description>What are the contact details for each employee?</Description>
  <!-- else -->
<!--     <Description>What is the contact information and social security number for each employee?</Description> -->
  <!-- endif -->
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_emp_contact.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_EMPLOYEE_CONTACT</ImageName>
	</Report>



	<Report ID="STDREP_LIST_OTHERNAME_PHONE" ReportNumericId="219" Name="Other Names Phone List">
		<Description>What are the phone numbers of the people on my Other Names list? What transaction names (such as ATM) are on the list?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_other_phone.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_OTHERNAME_PHONE</ImageName>
	</Report>



	<Report ID="STDREP_LIST_OTHERNAME_CONTACT" ReportNumericId="220" Name="Other Names Contact List">
		<Description>What is the contact information for each name?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_other_contact.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_OTHERNAME_CONTACT</ImageName>
	</Report>



	<Report ID="STDREP_LIST_ITEM_PRICELIST" ReportNumericId="221" Name="Item Price List">
		<Description>What is the price of each item or service my company sells?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_item_price.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_ITEM_PRICELIST</ImageName>
	</Report>



	<Report ID="STDREP_LIST_ITEM_DETAIL" ReportNumericId="222" Name="Item Listing">
		<Description>What is the latest information (price, cost, quantity on hand, etc.) for each product or service that my company sells?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_item_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_ITEM_DETAIL</ImageName>
	</Report>



	<Report ID="STDREP_LIST_PAYROLLITEM_DETAIL" ReportNumericId="223" Name="Payroll Item Listing">
		<Description>What is the latest information (amount, rate, annual limit, agency, etc.) for the line items in my company's payroll transactions?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_payitem.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_PAYROLLITEM_DETAIL</ImageName>
	</Report>


	<Report ID="STDREP_LIST_ACCOUNT_INCOMETAX" ReportNumericId="224" Name="Income Tax Preparation">
		<Description>What tax line is assigned to each account in my chart of accounts?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_account_tax.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_ACCOUNT_INCOMETAX</ImageName>
	</Report>



	<Report ID="STDREP_LIST_ACCOUNT_DETAIL" ReportNumericId="225" Name="Account Listing">
		<Description>What are the names of each of my company's accounts?  What is the current balance of each balance sheet account?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_account_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_ACCOUNT_DETAIL</ImageName>
	</Report>



	<Report ID="STDREP_LIST_TODO_DETAIL" ReportNumericId="226" Name="To Do Notes">
		<Description>What tasks on my To Do list haven't been done yet?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_todo.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_TODO_DETAIL</ImageName>
	</Report>



	<Report ID="STDREP_LIST_TERMS_DETAIL" ReportNumericId="227" Name="Terms Listing">
		<Description>What are the due dates and discounts available for customer payments and payments to Suppliers?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_terms.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_TERMS_DETAIL</ImageName>
	</Report>



<!-- ifdef INTL_AU -->
  <Report ID="STDREP_LIST_MTRANS_DETAIL" ReportNumericId="228" Name="Memorised Transaction Listing">
    <Description>What is the latest information for all memorised transactions?</Description>
<!-- else -->
<!--  <Report ID="STDREP_LIST_MTRANS_DETAIL" ReportNumericId="228" Name="Memorized Transaction Listing"> -->
<!--		<Description>What is the latest information for all memorized transactions?</Description> -->
<!-- endif -->
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_memtrans.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_MTRANS_DETAIL</ImageName>
	</Report>



	<Report ID="STDREP_LIST_EMPLOYEE_WITHHOLDING" ReportNumericId="229" Name="Employee Withholding">
		<Description>What is the federal and state withholding information for each employee?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_emp_withhold.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_EMPLOYEE_WITHHOLDING</ImageName>
	</Report>



	<Report ID="STDREP_QBP_ITEMDETAIL" ReportNumericId="234" Name="Payroll Item Detail">
		<Description>What is the line-by-line breakdown of each recent payroll transaction by item?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_pitem_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_QBP_ITEMDETAIL</ImageName>
	</Report>



	<Report ID="STDREP_QBP_TRANSJOURNAL" ReportNumericId="235" Name="Payroll Transaction Detail">
		<Description>What is the line-by-line breakdown of each recent payroll transaction by employee?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_payroll_journal.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_QBP_TRANSJOURNAL</ImageName>
	</Report>



	<Report ID="STDREP_QBP_TRANS" ReportNumericId="236" Name="Payroll Transactions by Payee">
		<Description>Who received paychecks and what was the net pay? What payroll liability checks were written for payroll taxes and expenses?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_payroll_transaction.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_QBP_TRANS</ImageName>
	</Report>



	<Report ID="STDREP_PROJ_BILLABLES" ReportNumericId="237" Name="Unbilled Costs by Job">
		<Description>What job-related expenses haven't been charged to customers?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_costs_by_job.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PROJ_BILLABLES</ImageName>
	</Report>



	<Report ID="STDREP_CASHFLOW_STD" ReportNumericId="238" Name="Statement of Cash Flows">
		<Description>What was the cash inflow (from profit and additional cash received) and cash outflow (cash spent) during a specific period of time?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_cashflow_stmt.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_CASHFLOW_STD</ImageName>
	</Report>



	<Report ID="STDREP_INV_OPENPOBYJOB" ReportNumericId="241" Name="Open Purchase Orders by Job">
		<Description>What purchase orders are currently open (i.e., have items still on order) for each job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_po_openbyjob.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INV_OPENPOBYJOB</ImageName>
	</Report>


<!-- #ifdef INTL_AU -->
	<Report ID="STDREP_GRAPHARSUMMARY" ReportNumericId="243" Name="Accounts Receivable Graph">
		<Description>For the total amount owed by my customers, what proportion of that amount is overdue? 
			( i.e., show me a graph of the information in the A/R ageing summary report.)</Description>
		<HelpTopic>REPORTS_N.CHM::/graphs_n/graph_ar.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_GRAPHARSUMMARY</ImageName>
	</Report>



  <Report ID="STDREP_GRAPHAPSUMMARY" ReportNumericId="244" Name="Accounts Payable Graph">
    <Description>
      For the total amount owed to Suppliers, what proportion of that amount is overdue?
      (i.e., show me a graph of the information in the A/P ageing summary report.)
    </Description>
    <HelpTopic>REPORTS_N.CHM::/graphs_n/graph_ap.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_GRAPHAPSUMMARY</ImageName>
  </Report>


  <!-- else -->
  <!--
  	<Report ID="STDREP_GRAPHARSUMMARY" ReportNumericId="243" Name="Accounts Receivable Graph">
		<Description>For the total amount owed by my customers, what proportion of that amount is overdue? 
			( i.e., show me a graph of the information in the A/R aging summary report.)</Description>
		<HelpTopic>REPORTS_N.CHM::/graphs_n/graph_ar.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_GRAPHARSUMMARY</ImageName>
	</Report>
    <Report ID="STDREP_GRAPHAPSUMMARY" ReportNumericId="244" Name="Accounts Payable Graph">
    <Description>
      For the total amount owed to Suppliers, what proportion of that amount is overdue?
      (i.e., show me a graph of the information in the A/P aging summary report.)
    </Description>
    <HelpTopic>REPORTS_N.CHM::/graphs_n/graph_ap.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_GRAPHAPSUMMARY</ImageName>
  </Report>

  -->
  <!-- endif -->


<!-- ifdef INTL_AU -->
  <Report ID="STDREP_QBP_EMPSTATETAXESDETAIL" ReportNumericId="246" Name="State Payroll Tax Detail">
<!-- else -->
    <!-- <Report ID="STDREP_QBP_EMPSTATETAXESDETAIL" ReportNumericId="246" Name="Employee State Taxes Detail"> -->
<!-- endif -->
		<Description>What wage and withholding information do I need for my state payroll taxes?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_emp_state_taxes.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_QBP_EMPSTATETAXESDETAIL</ImageName>
	</Report>

  <!-- ShiY Add a new report link -->
  <Report ID="STDREP_SUPER_REPORT_BY_EMPLOYEE" ReportNumericId="9025" Name="Super Report By Employee">
    <Description>What are the superannuation details for each employee?</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_emp_state_taxes.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_SUPER_REPORT_BY_EMPLOYEE</ImageName>
  </Report>
  
  
	<Report ID="STDREP_PROCESSEDPMNTS_DETAIL" ReportNumericId="247" Name="Online Received Payments">
		<Description>What online payments has my company received through QuickBooks Billing Solutions, Virtual Terminal Plus, or Automated Credit Card Billing?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_online_pmts_recd.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PROCESSEDPMNTS_DETAIL</ImageName>
	</Report>


	<Report ID="STDREP_TEJ_ESTIMATES_BYJOB" ReportNumericId="249" Name="Estimates by Job">
		<Description>What estimates have been assigned to each customer or job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_est_by_job.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TEJ_ESTIMATES_BYJOB</ImageName>
	</Report>
<!--ifdef INTL_AU WYQ-->
   <Report ID="STDREP_TAXLIABILITY_AU" ReportNumericId="9005" Name="Tax Liability">
<!--else	<Report ID="STDREP_SALESTAX" ReportNumericId="250" Name="Tax Liability"-->
<!--endif-->     
		<Description>For my company's total sales, how much is taxable, at what rate, and how much tax is currently due to be paid?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_ap_salestax.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_SALESTAX</ImageName>
	</Report>


  <!--ifdef INTL_AU-->
  <Report ID="STDREP_VATSUMMARY_AU" ReportNumericId="9006" Name="Tax Summary">
    <!--else-->
	<!--<Report ID="STDREP_SALESTAXREVENUE" ReportNumericId="251" Name="Tax Revenue Summary">-->
  <!--  endif-->
		<Description>For my company's total sales, how much is taxable?  For the non-taxable sales, how much is for non-taxable labor?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_st_revenue_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_SALESTAXREVENUE</ImageName>
	</Report>



	<Report ID="STDREP_QBP_YTDDETAIL" ReportNumericId="253" Name="Payroll Detail Review">
<!-- ifdef INTL_AU -->
    <Description>What values are used to calculate individual payroll items on employee payments?</Description>
<!-- else -->
    <!-- <Description>What values are used to calculate individual payroll items on employee paychecks?</Description> -->
<!-- endif -->
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_po_ytddetail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_QBP_YTDDETAIL</ImageName>
	</Report>

	<Report ID="STDREP_CLOSINGDATE_AUDITTRAIL" ReportNumericId="254" Name="Closing Date Exception Report">
		<Description>What changes were made after the last closing date was set to transactions dated on or before that closing date?</Description>
		<HelpTopic>Premier_n.chm::/rptdesc_from_premier_n/rpt_closing_date.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_CLOSINGDATE_AUDITTRAIL</ImageName>
	</Report>

	<Report ID="STDREP_VOID_DELETE_CANCEL_SUMMARY" ReportNumericId="358" Name="Voided/Deleted Transactions Summary">
		<Description>Which transactions have been voided or deleted?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_trans_deleted.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_VOID_DELETE_CANCEL_SUMMARY</ImageName>
	</Report>

	<Report ID="STDREP_VOID_DELETE_CANCEL" ReportNumericId="357" Name="Voided/Deleted Transactions Detail">
		<Description>What is the detailed history of voided and deleted transactions?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_trans_deleted_history.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_VOID_DELETE_CANCEL_HISTORY</ImageName>
	</Report>


	<!-- TODO: check the help topic -->
	<Report ID="STDREP_RECON_DISCREP" ReportNumericId="255" Name="Reconciliation Discrepancy">
		<Description>For a specified account, what reconciled transactions have been modified since this account was last reconciled? (You'll be prompted for some account information before you can display this report.)</Description>
		<HelpTopic>vm_n.chm::/acct_n/rpt_discrepancy.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_RECON_DISCREP</ImageName>
	</Report>



	<Report ID="STDREP_INV_SALESORDERS_BY_CUST" ReportNumericId="258" Name="Open Sales Orders by Customer">
		<Description>What are the open sales orders for each customer or job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/RPT_SO_BY_CUST.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INV_SALESORDERS_BY_CUST</ImageName>
	</Report>



	<Report ID="STDREP_PANDL_UNCLASSIFIED_SMRY" ReportNumericId="259" Name="Profit &amp; Loss Unclassified">
		<Description>How much money did my company make or lose that is not tracked through QuickBooks classes?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/RPT_PL_UNCLASSIFIED.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PANDL_UNCLASSIFIED_SMRY</ImageName>
	</Report>



	<Report ID="STDREP_LIST_HR_HIRE" ReportNumericId="260" Name="New Hire List">
		<Description>Who are the new employees that were hired by the company this month?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/LRPT_NEW_HIRE.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_HR_HIRE</ImageName>
	</Report>



	<Report ID="STDREP_LIST_HR_TERMINATION" ReportNumericId="261" Name="Terminated Employees List">
		<Description>Who are the employees that were terminated by the company this month?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/LRPT_TERMINATED_LIST.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_HR_TERMINATION</ImageName>
	</Report>



	<Report ID="STDREP_LIST_HR_EMERGENCY" ReportNumericId="263" Name="Emergency Contact List">
		<Description>What is the emergency contact information for each employee?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/LRPT_EMERGENCY_CONTACT.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_HR_EMERGENCY</ImageName>
	</Report>


	<Report ID="STDREP_LIST_EMPLOYEE_TIMEOFF" ReportNumericId="264" Name="Paid Time Off List">
<!-- ifdef INTL_AU -->
    <Description>What are the personal and holiday time balances for each employee?</Description>
<!-- else -->
    <!-- <Description>What are the sick and vacation time balances for each employee?</Description> -->
<!-- endif -->
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/LRPT_PAID_TIMEOFF.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_EMPLOYEE_TIMEOFF</ImageName>
	</Report>



	<Report ID="STDREP_INV_SALESORDERS_BY_ITEM" ReportNumericId="272" Name="Open Sales Orders by Item">
		<Description>What are the open sales orders for each item?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/RPT_SO_BY_ITEM.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_INV_SALESORDERS_BY_ITEM</ImageName>
	</Report>



	<Report ID="STDREP_PANDL_BUDGET_COMPARISON" ReportNumericId="273" Name="Profit &amp; Loss Budget Performance">
		<Description>How do the actual income and expenses compare to what has been budgeted for the current month and year? (You must have a budget set up before you can display this report. If not, you'll be prompted to set one up first.)</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_bud_pl_performance.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PANDL_BUDGET_COMPARISON</ImageName>
	</Report>



	<Report ID="STDREP_PENDING_BUILDS" ReportNumericId="275" Name="Pending Builds">
		<Description>Which builds are marked as pending, and what is the detailed information for each of them?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_pending_build.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PENDING_BUILDS</ImageName>
	</Report>



	<Report ID="STDREP_UNASSIGNED_JOB_EXPENSES" ReportNumericId="276" Name="Expenses Not Assigned to Jobs">
		<Description>What are the expenses that haven't been assigned to a customer or job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_unassigned_exp.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_UNASSIGNED_JOB_EXPENSES</ImageName>
	</Report>
	
	<Report ID="STDREP_LIST_JOB_STATUS" ReportNumericId="277" Name="Job Status">
		<Description>What is the status of all active jobs?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_job_status.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_JOB_STATUS</ImageName>
	</Report>



	<Report ID="STDREP_JOBCOSTS_BY_VENDOR" ReportNumericId="278" Name="Job Costs by Supplier &amp; Job Detail">
		<Description>What  are my company's job-related expenses for each supplier, subtotaled by job? What are the transactions for those expenses?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_jobcost_vendor.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_JOBCOSTS_BY_VENDOR</ImageName>
	</Report>



	<Report ID="STDREP_JOBCOSTS_DETAIL" ReportNumericId="279" Name="Job Costs Detail">
		<Description>What are the expenses my company has incurred for each job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_jobcost_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_JOBCOSTS_DETAIL</ImageName>
	</Report>



	<Report ID="STDREP_UNPAIDBILLS_BY_JOB" ReportNumericId="280" Name="Unpaid Bills by Job">
		<Description>For each job, which bills haven't been paid?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_bills_job.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_UNPAIDBILLS_BY_JOB</ImageName>
	</Report>



	<Report ID="STDREP_UNPAIDJOBBILLS_BY_VENDOR" ReportNumericId="281" Name="Unpaid Job Bills by Supplier">
		<Description>For each supplier, which bills haven't been paid?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_bills_vendor.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_UNPAIDJOBBILLS_BY_VENDOR</ImageName>
	</Report>



	<Report ID="STDREP_OPENPURCHASEORDERS_BY_VENDOR" ReportNumericId="282" Name="Open Purchase Orders by Supplier">
		<Description>What are the open purchase orders, by supplier?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_po_vendor.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_OPENPURCHASEORDERS_BY_VENDOR</ImageName>
	</Report>



	<Report ID="STDREP_OPENPURCHASEORDERS_BY_VENDORDETAIL" ReportNumericId="283" Name="Open Purchase Orders by Supplier Detail">
		<Description>What are the open purchase orders, by supplier, including detailed information about each transaction?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_po_vendor_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_OPENPURCHASEORDERS_BY_VENDORDETAIL</ImageName>
	</Report>



	<Report ID="STDREP_LIST_CERTIFIED_PAYROLL" ReportNumericId="284" Name="Certified Payroll - Box 1 Employee Information">
		<Description>What is each employee's social security number and address for filling out Box 1 of a Certified Payroll Report?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_payroll_box1.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_CERTIFIED_PAYROLL</ImageName>
	</Report>



	<Report ID="STDREP_LIST_VENDOR_ACCOUNTINFORMATION" ReportNumericId="285" Name="Supplier Account Information">
		<Description>What is the detailed information about each supplier, including balance and contact information?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_vendor_info.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_VENDOR_ACCOUNTINFORMATION</ImageName>
	</Report>



	<Report ID="STDREP_LIST_CUSTOMER_ACCOUNTINFORMATION" ReportNumericId="286" Name="Customer Account Information">
		<Description>What is the detailed information about each customer, including billing and contact information?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_cust_info.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_CUSTOMER_ACCOUNTINFORMATION</ImageName>
	</Report>



	<Report ID="STDREP_PANDL_BUDGET_OVERVIEW" ReportNumericId="287" Name="Budget Overview">
		<Description>What are my company's projected income and expenses for each month? (You must have a budget set up before you can display this report. If not, you'll be prompted to set one up first.)</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_bud_pl_overview.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PANDL_BUDGET_OVERVIEW</ImageName>
	</Report>



	<Report ID="STDREP_PANDL_BUDGET_VS_ACTUAL" ReportNumericId="288" Name="Budget vs. Actual">
		<Description>For the company as a whole, how do the actual income and expenses compare to what has been budgeted? (You must have a budget set up before you can display this report. If not, you'll be prompted to set one up first.)</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_bud_pl_vs_actual.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PANDL_BUDGET_VS_ACTUAL</ImageName>
	</Report>


	<Report ID="STDREP_FORECAST" ReportNumericId="291" Name="Forecast Overview">
		<Description>What are my company's forecasted income and expenses for each month? (You must have a forecast set up before you can display this report. If not, you'll be prompted to set one up first.)</Description>
		<HelpTopic>Premier_n.chm::/Forecasting_n/report_forecast_overview.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_FORECAST</ImageName>
	</Report>


	<!-- TODO: Help topic -->
	<Report ID="STDREP_PANDL_FORECAST" ReportNumericId="292" Name="Forecast vs. Actual">
		<Description>For the company as a whole, how do the actual income and expenses or account balances compare to what has been forecasted? (You must have a forecast set up before you can display this report. If not, you'll be prompted to set one up first.)</Description>
		<HelpTopic>Premier_n.chm::/Forecasting_n/report_forecast_vs_actual.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PANDL_FORECAST</ImageName>
	</Report>


	<!-- Same image as LIST_ACCOUNT_INCOMETAX -->
	<Report ID="STDREP_INCOMETAX_PREP" ReportNumericId="296" Name="Income Tax Preparation">
		<Description>What tax line is assigned to each account in my chart of accounts?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_account_tax.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_ACCOUNT_INCOMETAX</ImageName>
	</Report>



	<Report ID="STDREP_LAST_RECONBOTH" ReportNumericId="305" Name="Previous Reconciliation">
		<Description>What transactions were cleared or outstanding from a previous reconciliation? (You'll be prompted for some account information before you can display this report.)</Description>
		<HelpTopic>vm_n.chm::/acct_n/rpt_previous_reconcile_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LAST_RECONBOTH</ImageName>
	</Report>



	<Report ID="STDREP_MWD_SALES_VOLUME_BY_CUSTOMER" ReportNumericId="307" Name="Sales Volume by Customer">
		<Description>Which customers bring in the most revenue?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_mwd_sales_volume_by_customer.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_MWD_SALES_VOLUME_BY_CUSTOMER</ImageName>
	</Report>



	<Report ID="STDREP_MWD_SALES_BY_PRODUCT" ReportNumericId="308" Name="Sales by Product">
		<Description>What are my company's best-selling products?  Which products have brought in the most revenue?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_mwd_sales_by_product.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_MWD_SALES_BY_PRODUCT</ImageName>
	</Report>



	<Report ID="STDREP_MWD_SALES_BY_CUSTOMERTYPE" ReportNumericId="309" Name="Sales by Customer Type">
		<Description>Which group of customers provides my company with the most sales revenue?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_mwd_sales_by_customer_type.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_MWD_SALES_BY_CUSTOMERTYPE</ImageName>
	</Report>



	<Report ID="STDREP_MWD_PURCHASEORDER_BYITEM" ReportNumericId="310" Name="Open Purchase Orders by Item">
		<Description>Which items that are currently on order have not yet been received?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_mwd_open_purchase_orders_by_item.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_MWD_PURCHASEORDER_BYITEM</ImageName>
	</Report>


	<Report ID="STDREP_MWD_SALES_BYCLASSANDITEMTYPE" ReportNumericId="311" Name="Sales by Class &amp; Item Type">
		<Description>How much does my company make on each item type, listed by class?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_mwd_sales_by_class_and_item_type.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_MWD_SALES_BYCLASSANDITEMTYPE</ImageName>
	</Report>



	<Report ID="STDREP_MWD_INVENTORYREORDER_BYVENDOR" ReportNumericId="312" Name="Inventory Reorder by Supplier">
		<Description>From which Suppliers do I need to reorder inventory items?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_mwd_inventory_reorder_report_by_vendor.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_MWD_INVENTORYREORDER_BYVENDOR</ImageName>
	</Report>



	<Report ID="STDREP_LIST_PROJECTSTATUS" ReportNumericId="313" Name="Project Status">
		<Description>What is the status of all active projects?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_prof_project_status.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_PROJECTSTATUS</ImageName>
	</Report>



	<Report ID="STDREP_PROJECTCOSTS_DETAIL" ReportNumericId="314" Name="Project Costs Detail">
		<Description>What expenses has my company incurred for each project?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_prof_project_cost_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_PROJECTCOSTS_DETAIL</ImageName>
	</Report>



	<Report ID="STDREP_UNBILLED_EXPENSES_PROJECT" ReportNumericId="315" Name="Unbilled Expenses by Project">
		<Description>What expenses incurred for each project haven't been billed?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_prof_unbilled_expenses.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_UNBILLED_EXPENSES_PROJECT</ImageName>
	</Report>



	<Report ID="STDREP_UNASSIGNED_PROJECT_EXPENSES" ReportNumericId="316" Name="Expenses Not Assigned to Projects">
		<Description>What expenses haven't been assigned to a customer or project?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_prof_unassigned_exp.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_UNASSIGNED_PROJECT_EXPENSES</ImageName>
	</Report>



	<Report ID="STDREP_LIST_PROJECTCONTACT" ReportNumericId="317" Name="Project Contact List">
		<Description>What is the contact information and balance for each customer or project?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_prof_project_contact.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_PROJECTCONTACT</ImageName>
	</Report>



	<Report ID="STDREP_OPENBALANCES_CUSTOMER" ReportNumericId="318" Name="Open Balances by Customer/Project">
		<Description>Which invoices or statement charges haven't been paid, and when are they due?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_prof_open_balances.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_OPENBALANCES_CUSTOMER</ImageName>
	</Report>



  <Report ID="STDREP_ARAGING_DETAIL_CLASS" ReportNumericId="319" Name="A/R Aging Detail by Class">
		<Description>For each class (for example, for each partner), which invoices or statement charges are due and overdue?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_prof_ar_aging.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_ARAGING_DETAIL_CLASS</ImageName>
	</Report>
 


	<Report ID="STDREP_RETAIL_PNL_MONTHLY_COMPARISON" ReportNumericId="320" Name="Profit &amp; Loss Monthly Comparison">
		<Description>How does my company's profit and loss for this month compare to last month?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_rr_pl_monthly.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_RETAIL_PNL_MONTHLY_COMPARISON</ImageName>
	</Report>



	<Report ID="STDREP_RETAIL_BS_MONTHLY_COMPARISON" ReportNumericId="321" Name="Balance Sheet Monthly Comparison">
		<Description>How does my company's balance sheet compare to last month? Is my company's financial condition improving?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_rr_bal_sht_mthly.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_RETAIL_BS_MONTHLY_COMPARISON</ImageName>
	</Report>



	<Report ID="STDREP_RETAIL_GROSSMARGIN_BY_ITEM" ReportNumericId="322" Name="Gross Margin by Inventory Item">
		<Description>If my company records each sales transaction, what is its gross margin for each inventory item?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_rr_gr_mgn_item.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_RETAIL_GROSSMARGIN_BY_ITEM</ImageName>
	</Report>



	<Report ID="STDREP_RETAIL_CUSTPMT_BYPMTITEM" ReportNumericId="323" Name="Customer Payments by Payment Item">
		<Description>What methods are my customers using to provide payment? What are the monthly payments trends from the past year?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_rr_rcpt_pay_mtd.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_RETAIL_CUSTPMT_BYPMTITEM</ImageName>
	</Report>



	<Report ID="STDREP_RETAIL_BILLS_BY_DUEDATE" ReportNumericId="324" Name="Bills by Due Date">
		<Description>What bills are due and when? Which bills are due first?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_rr_bills_dd.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_RETAIL_BILLS_BY_DUEDATE</ImageName>
	</Report>



	<Report ID="STDREP_RETAIL_MONTHLY_SALES_BY_CUST" ReportNumericId="325" Name="Monthly Sales by Customer">
		<Description>If my company tracks sales by customer, who were the best customers and what was their sales activity over the last fiscal year?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_rr_mon_sales_cust.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_RETAIL_MONTHLY_SALES_BY_CUST</ImageName>
	</Report>



	<Report ID="STDREP_RETAIL_VNDR_BY_PURCHASE_VOL" ReportNumericId="326" Name="Purchase Volume by Supplier">
		<Description>From which Suppliers does my company purchase the most goods?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_rr_vend_pur.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_RETAIL_VNDR_BY_PURCHASE_VOL</ImageName>
	</Report>



	<Report ID="STDREP_RETAIL_VNDR_RETURNS_SMRY" ReportNumericId="327" Name="Supplier Returns Summary">
		<Description>Which Suppliers generate the largest volume of returned goods?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_rr_ven_rt_sum.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_RETAIL_VNDR_RETURNS_SMRY</ImageName>
	</Report>



	<Report ID="STDREP_RETAIL_VNDR_RETURNS_DETAIL" ReportNumericId="328" Name="Supplier Returns Detail">
		<Description>What goods are most commonly returned to each supplier?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_rr_ven_rt_det.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_RETAIL_VNDR_RETURNS_DETAIL</ImageName>
	</Report>



	<Report ID="STDREP_ADJUSTED_TRIAL_BALANCE" ReportNumericId="329" Name="Adjusted Trial Balance">
		<Description>For accountants only. What are the effects of my adjustments on the trial balance?</Description>
		<HelpTopic>Acct_n.chm::/accountant_n/rpt_adj_trial_balance.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_ADJUSTED_TRIAL_BALANCE</ImageName>
	</Report>



	<Report ID="STDREP_ADJUSTING_JOURNAL_ENTRIES" ReportNumericId="330" Name="Adjusting Journal Entries">
		<Description>For accountants only. Lists all adjustments you've made.</Description>
		<HelpTopic>Acct_n.chm::/accountant_n/rpt_adj_journal_entries.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_ADJUSTING_JOURNAL_ENTRIES</ImageName>
	</Report>



	<Report ID="STDREP_FIXED_ASSET_LIST" ReportNumericId="331" Name="Fixed Asset Listing">
		<Description>For my company's fixed assets, what are the purchase date, description, and original cost of each asset?</Description>
		<HelpTopic>accounts_n.chm::/fixed_assets_n/rpt_fixed_asset.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_FIXED_ASSET_LIST</ImageName>
	</Report>



	<Report ID="STDREP_MILEAGE_BY_VEHICLE_SUMMARY" ReportNumericId="333" Name="Mileage by Vehicle Summary">
		<Description>For each vehicle, what is the total mileage and the mileage expense? What is the total miles for all vehicles?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_miles_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_MILEAGE_BY_VEHICLE_SUMMARY</ImageName>
	</Report>



	<Report ID="STDREP_MILEAGE_BY_VEHICLE_DETAIL" ReportNumericId="334" Name="Mileage by Vehicle Detail">
		<Description>What is the trip information for each vehicle, including mileage, trip date, mileage rate, and mileage expense?  
			What is the total mileage and mileage expense for all vehicles?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_miles_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_MILEAGE_BY_VEHICLE_DETAIL</ImageName>
	</Report>



	<Report ID="STDREP_MILEAGE_BY_JOB_SUMMARY" ReportNumericId="335" Name="Mileage by Job Summary">
		<Description>For each job, what is the total mileage and the billable amount?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_miles_by_job_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_MILEAGE_BY_JOB_SUMMARY</ImageName>
	</Report>



	<Report ID="STDREP_MILEAGE_BY_JOB_DETAIL" ReportNumericId="336" Name="Mileage by Job Detail">
		<Description>What is the trip information for each job, including the vehicle used, mileage, trip date, mileage rate, and mileage expense?  
			What is the total mileage and mileage expense for all jobs?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_miles_by_job_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_MILEAGE_BY_JOB_DETAIL</ImageName>
	</Report>



	<Report ID="STDREP_WORKERSCOMP_SUMMARY" ReportNumericId="347" Name="Workers Compensation Summary">
		<Description>How much workers compensation insurance does my company owe?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_wc_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_WORKERSCOMP_SUMMARY</ImageName>
	</Report>



	<Report ID="STDREP_WORKERSCOMP_SUMMARY_EE" ReportNumericId="348" Name="Workers Compensation by Code and Employee">
		<Description>How much workers compensation insurance does my company owe for each employee?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_wc_bycodeandemp.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_WORKERSCOMP_SUMMARY_EE</ImageName>
	</Report>



	<Report ID="STDREP_WORKERSCOMP_SUMMARY_JOB" ReportNumericId="349" Name="Workers Compensation by Job Summary">
		<Description>How much workers compensation insurance does my company owe for each job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_wc_byjob.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_WORKERSCOMP_SUMMARY_JOB</ImageName>
	</Report>



	<Report ID="STDREP_WORKERSCOMP_DETAIL" ReportNumericId="350" Name="Workers Compensation Detail">
		<Description>What is the breakdown of my company's workers compensation premiums, by transaction?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_wc_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_WORKERSCOMP_DETAIL</ImageName>
	</Report>



	<Report ID="STDREP_WORKERSCOMP_LIST" ReportNumericId="351" Name="Workers Compensation Listing">
		<Description>What are my company's workers compensation job classification codes and their rates?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_wc.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_WORKERSCOMP_LIST</ImageName>
	</Report>

	<Report ID="STDREP_JOBCOSTS_BY_VENDORJOB_SMRY" ReportNumericId="352" Name="Job Costs by Supplier &amp; Job Summary">
		<Description>What are my company's job-related expenses for each supplier, subtotaled by job?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_jobcost_vendor_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_JOBCOSTS_BY_VENDORJOB_SMRY</ImageName>
	</Report>

	<Report ID="STDREP_JOBCOSTS_BY_JOBVENDOR_SMRY" ReportNumericId="353" Name="Job Costs by Job &amp; Supplier Summary">
		<Description>What are my company's job-related expenses for each job, subtotaled by supplier?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_jobcost_job_summary.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_JOBCOSTS_BY_JOBVENDOR_SMRY</ImageName>
	</Report>

	<Report ID="STDREP_JOBCOSTS_BY_JOBVENDOR_DETAIL" ReportNumericId="354" Name="Job Costs by Job &amp; Supplier Detail">
		<Description>What are my company's job-related expenses for each job, subtotaled by supplier? What are the transactions for those expenses?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_con_jobcost_job_detail.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_JOBCOSTS_BY_JOBVENDOR_DETAIL</ImageName>
	</Report>

	<Report ID="STDREP_NONPROFIT_BIGGEST_DONORS" ReportNumericId="368" Name="Biggest Donors/Grants">
		<Description>What are the largest contributions I have received, and which donors and grants did they come from?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_np_big_donors.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_NONPROFIT_BIGGEST_DONORS</ImageName>
	</Report>

	<Report ID="STDREP_NONPROFIT_BUDGET_VS_ACTUAL_BY_DONORS" ReportNumericId="369" Name="Budget vs. Actual by Donors/Grants">
		<Description>How do actual donations and grants compare with my budget?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_np_bva_donors.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_NONPROFIT_BUDGET_VS_ACTUAL_BY_DONORS</ImageName>
	</Report>
 
	<Report ID="STDREP_NONPROFIT_BUDGET_VS_ACTUAL_BY_PROGRAMS" ReportNumericId="370" Name="Budget vs. Actual by Programs/Projects">
		<Description>How much money was contributed to and spent on each program versus what was budgeted?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_np_bva_programs.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_NONPROFIT_BUDGET_VS_ACTUAL_BY_PROGRAMS</ImageName>
	</Report>
 
	<Report ID="STDREP_NONPROFIT_DONORS" ReportNumericId="371" Name="Donors/Grants Report">
		<Description>How much money was contributed by each donor or grant, and how much of that money has been spent?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_np_donors.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_NONPROFIT_DONORS</ImageName>
	</Report>
 
	<Report ID="STDREP_NONPROFIT_FINANCIAL_INCOME" ReportNumericId="372" Name="Statement of Financial Income and Expense">
		<Description>How much money came in (income) and how was it spent (expense)?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_np_fin_income.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_NONPROFIT_FINANCIAL_INCOME</ImageName>
	</Report>
 
	<Report ID="STDREP_NONPROFIT_FINANCIAL_POSITION" ReportNumericId="373" Name="Statement of Financial Position">
		<Description>What is my balance sheet today and how does it compare to last year at this time?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_np_fin_pos.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_NONPROFIT_FINANCIAL_POSITION</ImageName>
	</Report>
 
	<Report ID="STDREP_NONPROFIT_FUNCTIONAL_EXPENSES" ReportNumericId="374" Name="Statement of Functional Expenses (990)">
		<Description>What expenses do I report on IRS Form 990?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_np_func_exp.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_NONPROFIT_FUNCTIONAL_EXPENSES</ImageName>
	</Report>

	<Report ID="STDREP_NONPROFIT_PROGRAMS" ReportNumericId="375" Name="Programs/Projects Report">
		<Description>How much money was contributed to and spent on each program?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_np_programs.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_NONPROFIT_PROGRAMS</ImageName>
	</Report>
 
	<Report ID="STDREP_NONPROFIT_DONOR_CONTRIBUTION_SUMMARY" ReportNumericId="376" Name="Donor Contribution Summary">
		<Description>How much money was contributed by each donor or grant?</Description>
		<HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_np_donor_sum.html</HelpTopic>
		<ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_NONPROFIT_DONOR_CONTRIBUTION_SUMMARY</ImageName>
	</Report>

  <Report ID="STDREP_LIST_UOM_SETS" ReportNumericId="377" Name="Unit of Measure Set Listing">
    <Description>For each unit of measure set, what are the current base, purchase, sales, and shipping units?</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_uom_set.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_UNIT_OF_MEASURE_SETS</ImageName>
  </Report>

  <Report ID="STDREP_LIST_UOM_UNITS" ReportNumericId="378" Name="U/M Sets with Related Units">
    <Description>What related units are in each unit of measure set? How many base units does each related unit contain?</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_uom_unit.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_UNIT_OF_MEASURE_RELATED_UNITS</ImageName>
  </Report>

  <Report ID="STDREP_LIST_ITEM_BY_UOM_SET" ReportNumericId="379" Name="Items with Units of Measure">
    <Description>Which items are currently assigned units of meansure?</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/lrpt_uom_item.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_LIST_ITEMS_WITH_UNITS_OF_MEASURE</ImageName>
  </Report>

  <!--INTL_AU ShiY Online bank report -->
  <Report ID="STDREP_BANK_ONLINE" ReportNumericId="9026" Name="Bank(Online) Report">
    <Description>Lists online banking payments, including the Lodgement Reference and the amount for each employee.</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_emp_state_taxes.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_BANK_ONLINE</ImageName>
  </Report>
  <!-- end INTL_AU ShiY -->

  <!--INTL_AU Vat Exception Report -->
  <Report ID="STDREP_VATDETAIL" ReportNumericId="383" Name="Tax Detail">
    <Description>This is the report for Tax Detail</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_emp_state_taxes.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_TAX_DETAIL</ImageName>
  </Report>
  <!-- end INTL_AU Vat Exception Report -->

  <!--INTL_AU_MC Multicurrency Realised Gain & Loss Report -->
  <Report ID="STDREP_MULCURRENCY_REALGANDL" ReportNumericId="9023" Name="Realised Gain &amp; Loss">
    <Description>How much money could I potentially make or lose due to changes in the exchange rate?</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_mc_realised_gal.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/BMP_MULCURRENCY_REALGANDL</ImageName>
  </Report>
  <!-- end INTL_AU_MC Multicurrency Realised Gain & Loss Report -->

  <!--INTL_AU_MC Multicurrency Unrealised Gain & Loss Report -->
  <Report ID="STDREP_MULCURRENCY_UNREALGANDL" ReportNumericId="9024" Name="Unrealised Gain &amp; Loss">
    <Description>How much money did I potentially make or lose due to changes in the exchange rate?</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_mc_unrealised_gal.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/BMP_MULCURRENCY_UNREALGANDL</ImageName>
  </Report>
  <!-- end INTL_AU_MC Multicurrency Unrealised Gain & Loss Report -->

  <!--INTL_AU ADT Journal Report -->
  <Report ID="STDREP_ADT_JOURNAL_REPORT" ReportNumericId="9029" Name="ADT Journal">
    <Description>This is the report for ADT Journal</Description>
    <HelpTopic>REPORTS_N.CHM::/rptdesc_n/rpt_adt_journal_report.html</HelpTopic>
    <ImageName>res://%StartupDir%QBWRPT32.dll/REPGIF_ADT_JOURNAL</ImageName>
  </Report>
  <!-- end INTL_AU ADT Journal Report -->


  <AccessPointItem ID="REPAPI_PANDL_STD" Visible="true" Name="Standard">
		<ReportRef REFID="STDREP_PANDL_STD"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PANDL_COMP" Visible="true" Name="Prev Year Comparison">
		<ReportRef REFID="STDREP_PANDL_COMP"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PANDL_JOB" Visible="true" Name="By Job">
		<ReportRef REFID="STDREP_PANDL_JOB"/>
	</AccessPointItem>
	
	<!-- Amittal: Creating API for PANDL_JOB to solve name problem under diff subs -->
	<AccessPointItem ID="REPAPI_TEJ_PANDL_JOB" Visible="true" Name="Profit &amp; Loss by Job">
		<ReportRef REFID="STDREP_PANDL_JOB"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PANDL_CLASS" Visible="true" Name="By Class">
		<ReportRef REFID="STDREP_PANDL_CLASS"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PANDL_ITEMIZED" Visible="true" Name="Detail">
		<ReportRef REFID="STDREP_PANDL_ITEMIZED"/>
	</AccessPointItem>

<!-- ifdef INTL_AU -->

  <AccessPointItem ID="REPAPI_BS_AUSTD" Visible="true" Name="Balance Sheet">
    <ReportRef REFID="STDREP_BS_AUSTD"/>
  </AccessPointItem>

  <AccessPointItem ID="REPAPI_BS_AUCOMP" Visible="true" Name="Balance Sheet Prev Year Comparison">
    <ReportRef REFID="STDREP_BS_AUCOMP"/>
  </AccessPointItem>


  <AccessPointItem ID="REPAPI_BS_AUSMRY" Visible="true" Name="Balance Sheet Summary">
    <ReportRef REFID="STDREP_BS_AUSMRY"/>
  </AccessPointItem>

  <AccessPointItem ID="REPAPI_BS_AUITEMIZED" Visible="true" Name="Balance Sheet Detail">
    <ReportRef REFID="STDREP_BS_AUITEMIZED"/>
  </AccessPointItem>

<!-- else -->

  <AccessPointItem ID="REPAPI_BS_STD" Visible="true" Name="QB Standard">
		<ReportRef REFID="STDREP_BS_STD"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_BS_COMP" Visible="true" Name="QB Prev Year Comparison">
		<ReportRef REFID="STDREP_BS_COMP"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_BS_SMRY" Visible="true" Name="QB Summary">
		<ReportRef REFID="STDREP_BS_SMRY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_BS_ITEMIZED" Visible="true" Name="QB Detail">
		<ReportRef REFID="STDREP_BS_ITEMIZED"/>
	</AccessPointItem>

<!-- endif -->

  <AccessPointItem ID="REPAPI_CASHFLOW_FORECAST" Visible="true" Name="Cash Flow Forecast">
		<ReportRef REFID="STDREP_CASHFLOW_FORECAST"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_SALES_SMRY" Visible="true" Name="Summary">
		<ReportRef REFID="STDREP_SALES_SMRY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_SALES_ITEMIZED" Visible="true" Name="Detail">
		<ReportRef REFID="STDREP_SALES_ITEMIZED"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_ARAGING_SMRY" Visible="true" Name="Summary">
		<ReportRef REFID="STDREP_ARAGING_SMRY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_ARAGING_DETAIL" Visible="true" Name="Detail">
		<ReportRef REFID="STDREP_ARAGING_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_COLLECT" Visible="true" Name="Collections">
		<ReportRef REFID="STDREP_COLLECT"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_APAGING_SMRY" Visible="true" Name="Summary">
		<ReportRef REFID="STDREP_APAGING_SMRY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_APAGING_DETAIL" Visible="true" Name="Detail">
		<ReportRef REFID="STDREP_APAGING_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TRANSBYACCNT" Visible="true" Name="Transaction Detail by Account">
		<ReportRef REFID="STDREP_TRANSBYACCNT"/>
		<Parameter Name="Accountant &amp; Taxes" Data="REPNAV_CAT_TAXES" /> 		
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TRANSBYCUST" Visible="true" Name="Transaction List by Customer">
		<ReportRef REFID="STDREP_TRANSBYCUST"/>
		<Parameter Name="Customers &amp; Receivables" Data="REPNAV_CAT_CUSTOMER" />
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TRANSBYVENDOR" Visible="true" Name="Transaction List by Supplier">
		<ReportRef REFID="STDREP_TRANSBYVENDOR"/>
		<Parameter Name="Suppliers &amp; Payables" Data="REPNAV_CAT_VENDOR"/>
	</AccessPointItem>


<!-- ifdef INTL_AU -->
  <AccessPointItem ID="REPAPI_MISSINGCHECK" Visible="true" Name="Missing Cheques">
<!-- else -->
  <!-- <AccessPointItem ID="REPAPI_MISSINGCHECK" Visible="true" Name="Missing Checks"> -->
<!-- endif -->
		<ReportRef REFID="STDREP_MISSINGCHECK"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_TRIALBAL" Visible="true" Name="Trial Balance">
		<ReportRef REFID="STDREP_TRIALBAL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_JOURNAL" Visible="true" Name="Journal">
		<ReportRef REFID="STDREP_JOURNAL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_GRAPHINCEXP" Visible="true" Name="Income &amp; Expense Graph">
		<ReportRef REFID="STDREP_GRAPHINCEXP"/>
		<Parameter Name="Company &amp; Financial" Data="REPNAV_CAT_FINANCIAL" /> 
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_GRAPHBALSHEET" Visible="true" Name="Net Worth Graph">
		<ReportRef REFID="STDREP_GRAPHBALSHEET"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_GRAPHBUDGET" Visible="true" Name="Budget vs. Actual Graph">
		<ReportRef REFID="STDREP_GRAPHBUDGET"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_GRAPHSALESBYITEM" Visible="true" Name="Sales Graph">
		<ReportRef REFID="STDREP_GRAPHSALESBYITEM"/>
	</AccessPointItem>

	<!-- AMittal: Not taking care of Canada in Topaz -->
	<!-- AccessPointItem ID="REPAPI_1099" Visible="Preferences.1099Enabled='1'" Name="Summary">
		<ReportRef REFID="STDREP_1099"/>
		<Parameter Name="Suppliers &amp; Payables" Data="REPNAV_CAT_VENDOR"/>
	</AccessPointItem -->

	<!-- AMittal: Not taking care of Canada in Topaz -->
	<!-- AccessPointItem ID="REPAPI_1099DETAIL" Visible="Preferences.1099Enabled='1'" Name="Detail">
		<ReportRef REFID="STDREP_1099DETAIL"/>		
	</AccessPointItem -->


	<AccessPointItem ID="REPAPI_GENLEDGER" Visible="true" Name="General Ledger">
		<ReportRef REFID="STDREP_GENLEDGER"/>
		<Parameter Name="Accountant &amp; Taxes" Data="REPNAV_CAT_TAXES" /> 
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_SALESBYCUSTSMRY" Visible="true" Name="Summary">
		<ReportRef REFID="STDREP_SALESBYCUSTSMRY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_SALESBYCUSTDETAIL" Visible="true" Name="Detail">
		<ReportRef REFID="STDREP_SALESBYCUSTDETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_OPENINVOICE" Visible="true" Name="Open Invoices">
		<ReportRef REFID="STDREP_OPENINVOICE"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_OPENBILL" Visible="true" Name="Unpaid Bills Detail">
		<ReportRef REFID="STDREP_OPENBILL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_SALESBYREPSMRY" Visible="true" Name="Summary">
		<ReportRef REFID="STDREP_SALESBYREPSMRY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_SALESBYREPDETAIL" Visible="true" Name="Detail">
		<ReportRef REFID="STDREP_SALESBYREPDETAIL"/>
	</AccessPointItem>
	
	<!-- Amittal: Creating a new API to solve the diff. name problem under diff sub-cat -->
	<AccessPointItem ID="REPAPI_MWD_SALESBYREPDETAIL" Visible="true" Name="By Rep Detail">
		<ReportRef REFID="STDREP_SALESBYREPDETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_CUSTBALSMRY" Visible="true" Name="Summary">
		<ReportRef REFID="STDREP_CUSTBALSMRY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_VENDBALSMRY" Visible="true" Name="Supplier Balance Summary">
		<ReportRef REFID="STDREP_VENDBALSMRY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_CUSTBALDETAIL" Visible="true" Name="Detail">
		<ReportRef REFID="STDREP_CUSTBALDETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_VENDBALDETAIL" Visible="true" Name="Supplier Balance Detail">
		<ReportRef REFID="STDREP_VENDBALDETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_INCCUSTSMRY" Visible="true" Name="Income by Customer Summary">
		<ReportRef REFID="STDREP_INCCUSTSMRY"/>
		<Parameter Name="Company &amp; Financial" Data="REPNAV_CAT_FINANCIAL" /> 
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_INCCUSTDETAIL" Visible="true" Name="Income by Customer Detail">
		<ReportRef REFID="STDREP_INCCUSTDETAIL"/>	
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_EXPVENDSMRY" Visible="true" Name="Expenses by Supplier Summary">
		<ReportRef REFID="STDREP_EXPVENDSMRY"/>
		<Parameter Name="Company &amp; Financial" Data="REPNAV_CAT_FINANCIAL" /> 				
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_EXPVENDDETAIL" Visible="true" Name="Expenses by Supplier Detail">
		<ReportRef REFID="STDREP_EXPVENDDETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PANDL_YTD" Visible="true" Name="YTD Comparison">
		<ReportRef REFID="STDREP_PANDL_YTD"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_AUDITTRAIL" Visible="true" Name="Audit Trail">
		<ReportRef REFID="STDREP_AUDITTRAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PURCH_SMRY" Visible="true" Name="Summary">
		<ReportRef REFID="STDREP_PURCH_SMRY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PURCH_ITEMIZED" Visible="true" Name="Detail">
		<ReportRef REFID="STDREP_PURCH_ITEMIZED"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PURCHBYVENDSMRY" Visible="Inventory='1'" Name="Summary">
		<ReportRef REFID="STDREP_PURCHBYVENDSMRY"/>
		<Parameter Name="Purchases" Data="REPNAV_CAT_PURCHASES" />
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PURCHBYVENDDETAIL" Visible="true" Name="Detail">
		<ReportRef REFID="STDREP_PURCHBYVENDDETAIL"/>
	</AccessPointItem>


<!-- ifdef INTL_AU -->
  <AccessPointItem ID="REPAPI_INV_STOCKBYITEM" Visible="true" Name="Inventory Status by Item">
    <ReportRef REFID="STDREP_INV_STOCKBYITEM"/>
  </AccessPointItem>
<!-- else -->
<!-- <AccessPointItem ID="REPAPI_INV_STOCKBYITEM" Visible="true" Name="Inventory Stock Status by Item"> -->
<!--   <ReportRef REFID="STDREP_INV_STOCKBYITEM"/> -->
<!-- </AccessPointItem> -->
<!-- endif -->


<!-- ifdef INTL_AU -->
  <AccessPointItem ID="REPAPI_INV_STOCKBYVEND" Visible="true" Name="Inventory Status by Supplier">
    <ReportRef REFID="STDREP_INV_STOCKBYVEND"/>
	</AccessPointItem>
<!-- else -->
<!-- <AccessPointItem ID="REPAPI_INV_STOCKBYVEND" Visible="true" Name="Inventory Stock Status by Supplier"> -->
<!--   <ReportRef REFID="STDREP_INV_STOCKBYVEND"/> -->
<!-- </AccessPointItem> -->
<!-- endif -->


	<AccessPointItem ID="REPAPI_INV_VALSMRY" Visible="true" Name="Summary">
		<ReportRef REFID="STDREP_INV_VALSMRY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_INV_VALDETAIL" Visible="true" Name="Detail">
		<ReportRef REFID="STDREP_INV_VALDETAIL"/>
	</AccessPointItem>


<!-- ifdef INTL_AU -->
  <AccessPointItem ID="REPAPI_INV_PHYSWKSHT" Visible="Inventory='1'" Name="Stock Take Worksheet">
<!-- else -->
    <!--  <AccessPointItem ID="REPAPI_INV_PHYSWKSHT" Visible="Inventory='1'" Name="Physical Inventory Worksheet"> -->
<!-- endif -->
		<ReportRef REFID="STDREP_INV_PHYSWKSHT"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_QBP_SMRY" Visible="PRIntegrated='1'" Name="Payroll Summary">
		<ReportRef REFID="STDREP_QBP_SMRY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_QBP_LIAB" Visible="PRIntegrated='1'" Name="Payroll Liability Balances">
		<ReportRef REFID="STDREP_QBP_LIAB"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_OPENPO" Visible="Inventory='1'" Name="Open Purchase Orders">
		<ReportRef REFID="STDREP_OPENPO"/>		
		<Parameter Name="Purchases" Data="REPNAV_CAT_PURCHASES" /> 
	</AccessPointItem>


  <!-- ifdef INTL_AU -->
  <AccessPointItem ID="REPAPI_CHECKDETAIL" Visible="true" Name="Cheque Detail">
    <!-- else -->
<!--  <AccessPointItem ID="REPAPI_CHECKDETAIL" Visible="true" Name="Check Detail"> -->
    <!-- endif -->
		<ReportRef REFID="STDREP_CHECKDETAIL"/>
		<Parameter Name="Banking" Data="REPNAV_CAT_BANKING" />
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_DEPOSITDETAIL" Visible="true" Name="Deposit Detail">
		<ReportRef REFID="STDREP_DEPOSITDETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_INCOMETAX_SMRY" Visible="true" Name="Summary">
		<ReportRef REFID="STDREP_INCOMETAX_SMRY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_TM_JOB" Visible="TrackingTime='1'" Name="By Job Summary">
		<ReportRef REFID="STDREP_TEJ_TM_JOB"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_TM_ITEM" Visible="TrackingTime='1'" Name="By Item">
		<ReportRef REFID="STDREP_TEJ_TM_ITEM"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_JOB_PROFIT" Visible="true" Name="Job Profitability Summary">
		<ReportRef REFID="STDREP_TEJ_JOB_PROFIT"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_JOB_PROF_DET" Visible="true" Name="Job Profitability Detail">
		<ReportRef REFID="STDREP_TEJ_JOB_PROF_DET"/>
	</AccessPointItem>

	<!-- SKU and Pref -->
	<AccessPointItem ID="REPAPI_TEJ_JOB_EST" Visible="Features.PRO_LegacyFeatures='enabled' AND Estimating='1'" Name="Job Estimates vs. Actuals Summary">
		<ReportRef REFID="STDREP_TEJ_JOB_EST"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_JOB_EST_DET" Visible="Features.PRO_LegacyFeatures='enabled' AND Estimating='1'" Name="Job Estimates vs. Actuals Detail">
		<ReportRef REFID="STDREP_TEJ_JOB_EST_DET"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_ITEM_PROFIT" Visible="true" Name="Item Profitability">
		<ReportRef REFID="STDREP_TEJ_ITEM_PROFIT"/>
	</AccessPointItem>

	<!-- SKU and Pref -->
	<AccessPointItem ID="REPAPI_TEJ_ITEM_EST" Visible="Features.PRO_LegacyFeatures='enabled' AND Estimating='1'" Name="Item Estimates vs. Actuals">
		<ReportRef REFID="STDREP_TEJ_ITEM_EST"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_TM_DETAIL" Visible="TrackingTime='1'" Name="By Job Detail">
		<ReportRef REFID="STDREP_TEJ_TM_DETAIL"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_TEJ_TM_EMP" Visible="TrackingTime='1'" Name="By Name">
		<ReportRef REFID="STDREP_TEJ_TM_EMP"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_PROGRESS_BILLING" Visible="Features.PRO_LegacyFeatures='enabled' AND Estimating='1' AND Preferences.IsProgressInvoiceActive='1'" Name="Job Progress Invoices vs. Estimates">
		<ReportRef REFID="STDREP_TEJ_PROGRESS_BILLING"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_TMNAME_BILLABLESTATUS" Visible="TrackingTime='1'" Name="By Person">
		<ReportRef REFID="STDREP_TEJ_TMNAME_BILLABLESTATUS"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_TMNAMEJOB_BILLABLESTATUS" Visible="true" Name="By Person &amp; Job">
		<ReportRef REFID="STDREP_TEJ_TMNAMEJOB_BILLABLESTATUS"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_TMNAMEITEM_BILLABLESTATUS" Visible="TrackingTime='1'" Name="By Person &amp; Activity">
		<ReportRef REFID="STDREP_TEJ_TMNAMEITEM_BILLABLESTATUS"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_MWD_PROFITABILITY_PRODUCT" Visible="true" Name="Profitability by Product">
		<ReportRef REFID="STDREP_TEJ_MWD_PROFITABILITY_PRODUCT"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_PROSVC_TMNAMEPROJECT" Visible="TrackingTime='1'" Name="By Person &amp; Project">
		<ReportRef REFID="STDREP_TEJ_PROSVC_TMNAMEPROJECT"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_BILLEDVSPROPOSAL_PROJECT" Visible="Estimating='1'" Name="Billed vs. Proposal by Project">
		<ReportRef REFID="STDREP_BILLEDVSPROPOSAL_PROJECT"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_RETAIL_ESTIMATES_BY_CUST" Visible="Estimating='1'" Name="Estimates by Customer">
		<ReportRef REFID="STDREP_TEJ_RETAIL_ESTIMATES_BY_CUST"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_INCOMETAX_DETAIL" Visible="true" Name="Detail">
		<ReportRef REFID="STDREP_INCOMETAX_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_QBP_EMPJOURNAL" Visible="PRIntegrated='1'" Name="Employee Earnings Summary">
		<ReportRef REFID="STDREP_QBP_EMPJOURNAL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PENDING_SALES" Visible="true" Name="Pending Sales">
		<ReportRef REFID="STDREP_PENDING_SALES"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TRANSBYDATE" Visible="true" Name="Transaction List by Date">
		<ReportRef REFID="STDREP_TRANSBYDATE"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_CUSTOMER_PHONE" Visible="true" Name="Customer Phone List">
		<ReportRef REFID="STDREP_LIST_CUSTOMER_PHONE"/>
	</AccessPointItem>
	
	<AccessPointItem ID="REPAPI_LIST_CUSTOMER_PHONE_LST" Visible="true" Name="Phone List">
		<ReportRef REFID="STDREP_LIST_CUSTOMER_PHONE"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_CUSTOMER_CONTACT" Visible="true" Name="Customer Contact List">
		<ReportRef REFID="STDREP_LIST_CUSTOMER_CONTACT"/>
	</AccessPointItem>
	
	<AccessPointItem ID="REPAPI_LIST_CUSTOMER_CONTACT_LST" Visible="true" Name="Contact List">
		<ReportRef REFID="STDREP_LIST_CUSTOMER_CONTACT"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_VENDOR_PHONE" Visible="true" Name="Supplier Phone List">
		<ReportRef REFID="STDREP_LIST_VENDOR_PHONE"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_LIST_VENDOR_PHONE_LST" Visible="true" Name="Phone List">
		<ReportRef REFID="STDREP_LIST_VENDOR_PHONE"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_LIST_VENDOR_CONTACT" Visible="true" Name="Supplier Contact List">
		<ReportRef REFID="STDREP_LIST_VENDOR_CONTACT"/>
		<Parameter Name="Suppliers &amp; Payables" Data="REPNAV_CAT_VENDOR" /> 		
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_LIST_VENDOR_CONTACT_LST" Visible="true" Name="Contact List">
		<ReportRef REFID="STDREP_LIST_VENDOR_CONTACT"/>		
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_LIST_EMPLOYEE_CONTACT" Visible="true" Name="Employee Contact List">
		<ReportRef REFID="STDREP_LIST_EMPLOYEE_CONTACT"/>
	</AccessPointItem>
	
	<!-- Amittal: Duplicating API to solve the name problem under diff subs -->
	<AccessPointItem ID="REPAPI_LIST_EMPLOYEE_CONTACT_LST" Visible="true" Name="Contact List">
		<ReportRef REFID="STDREP_LIST_EMPLOYEE_CONTACT"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_OTHERNAME_PHONE" Visible="true" Name="Phone List">
		<ReportRef REFID="STDREP_LIST_OTHERNAME_PHONE"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_OTHERNAME_CONTACT" Visible="true" Name="Contact List">
		<ReportRef REFID="STDREP_LIST_OTHERNAME_CONTACT"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_ITEM_PRICELIST" Visible="true" Name="Item Price List">
		<ReportRef REFID="STDREP_LIST_ITEM_PRICELIST"/>
		<Parameter Name="Customers &amp; Receivables" Data="REPNAV_CAT_CUSTOMER" />
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_ITEM_DETAIL" Visible="true" Name="Item Listing">
		<ReportRef REFID="STDREP_LIST_ITEM_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_PAYROLLITEM_DETAIL" Visible="PRIntegrated='1'" Name="Payroll Item Listing">
		<ReportRef REFID="STDREP_LIST_PAYROLLITEM_DETAIL"/>
	</AccessPointItem>

	<!-- Turn this report ON only if RPT_IncomeTaxPrepReport is not enabled. When the feature is enabled, this report 
		is replaced	by STDREP_INCOMETAX_PREP -->
	<AccessPointItem ID="REPAPI_LIST_ACCOUNT_INCOMETAX" Visible="Features.RPT_IncomeTaxPrepReport='disabled'" 
		Name="Preparation">
		<ReportRef REFID="STDREP_LIST_ACCOUNT_INCOMETAX"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_LIST_ACCOUNT_DETAIL" Visible="true" Name="Account Listing">
		<ReportRef REFID="STDREP_LIST_ACCOUNT_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_TODO_DETAIL" Visible="true" Name="To Do Notes">
		<ReportRef REFID="STDREP_LIST_TODO_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_TERMS_DETAIL" Visible="true" Name="Terms Listing">
		<ReportRef REFID="STDREP_LIST_TERMS_DETAIL"/>
	</AccessPointItem>


<!-- ifdef INTL_AU -->
  <AccessPointItem ID="REPAPI_LIST_MTRANS_DETAIL" Visible="true" Name="Memorised Transaction Listing">
<!-- else -->
  <!-- <AccessPointItem ID="REPAPI_LIST_MTRANS_DETAIL" Visible="true" Name="Memorized Transaction Listing"> -->
<!-- endif -->
		<ReportRef REFID="STDREP_LIST_MTRANS_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_EMPLOYEE_WITHHOLDING" Visible="PRIntegrated='1'" Name="Employee Withholding">
		<ReportRef REFID="STDREP_LIST_EMPLOYEE_WITHHOLDING"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_QBP_ITEMDETAIL" Visible="PRIntegrated='1'" Name="Payroll Item Detail">
		<ReportRef REFID="STDREP_QBP_ITEMDETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_QBP_TRANSJOURNAL" Visible="PRIntegrated='1'" Name="Payroll Transaction Detail">
		<ReportRef REFID="STDREP_QBP_TRANSJOURNAL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_QBP_TRANS" Visible="PRIntegrated='1'" Name="Payroll Transactions by Payee">
		<ReportRef REFID="STDREP_QBP_TRANS"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PROJ_BILLABLES" Visible="true" Name="Unbilled Costs by Job">
		<ReportRef REFID="STDREP_PROJ_BILLABLES"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_CASHFLOW_STD" Visible="true" Name="Statement of Cash Flows">
		<ReportRef REFID="STDREP_CASHFLOW_STD"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_INV_OPENPOBYJOB" Visible="Inventory='1'" Name="Open Purchase Orders by Job">
		<ReportRef REFID="STDREP_INV_OPENPOBYJOB"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_GRAPHARSUMMARY" Visible="true" Name="Accounts Receivable Graph">
		<ReportRef REFID="STDREP_GRAPHARSUMMARY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_GRAPHAPSUMMARY" Visible="true" Name="Accounts Payable Graph">
		<ReportRef REFID="STDREP_GRAPHAPSUMMARY"/>
	</AccessPointItem>

  <!-- INTL_AU michael davis add new report links -->
  <AccessPointItem ID="STDREP_AU_PAYROLL_TOTALS_SMRY_RPT" Visible="PRIntegrated='1'" Name="Payroll Totals">
    <ReportRef REFID="STDREP_AU_PAYROLL_TOTALS_SMRY_RPT"/>
  </AccessPointItem>
  
<!-- ifdef INTL_AU -->
  <AccessPointItem ID="REPAPI_QBP_EMPSTATETAXESDETAIL" Visible="PRIntegrated='1'" Name="State Payroll Tax Detail">
<!-- else -->
    <!--  <AccessPointItem ID="REPAPI_QBP_EMPSTATETAXESDETAIL" Visible="PRIntegrated='1'" Name="Employee State Taxes Detail"> -->
<!-- endif -->
		<ReportRef REFID="STDREP_QBP_EMPSTATETAXESDETAIL"/>
	</AccessPointItem>

  <!-- INTL_AU ShiY add new report links -->
  <AccessPointItem ID="REPAPI_SUPER_REPORT_BY_EMPLOYEE" Visible="PRIntegrated='1'" Name="Super Report By Employee">
    <ReportRef REFID="STDREP_SUPER_REPORT_BY_EMPLOYEE"/>
  </AccessPointItem>

  
  
  <AccessPointItem ID="REPAPI_BANK_ONLINE" Visible="true" Name="Bank(Online) Report">
    <ReportRef REFID="STDREP_BANK_ONLINE"/>
  </AccessPointItem>
  <!-- INTL_AU End ShiY -->

	<AccessPointItem ID="REPAPI_PROCESSEDPMNTS_DETAIL" Visible="IPPActive='1'" Name="Online Received Payments">
		<ReportRef REFID="STDREP_PROCESSEDPMNTS_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_TEJ_ESTIMATES_BYJOB" Visible="Features.PRO_LegacyFeatures='enabled' AND Estimating='1'" Name="Estimates by Job">
		<ReportRef REFID="STDREP_TEJ_ESTIMATES_BYJOB"/>
	</AccessPointItem>

	<!-- ON if Sales Tax is ON -->
	<AccessPointItem ID="REPAPI_SALESTAX" Visible="SalesTax='1'" Name="Tax Liability">
<!--INTL_AU WYQ-->
    <ReportRef REFID="STDREP_TAXLIABILITY_AU"/>    
<!--else    
		<ReportRef REFID="STDREP_SALESTAX"/>
endif-->      
		<Parameter Name="Suppliers &amp; Payables" Data="REPNAV_CAT_VENDOR"/>
	</AccessPointItem>

	<!-- ON if Sales Tax is ON -->
  <!--ifdef INTL_AU-->
	<AccessPointItem ID="REPAPI_SALESTAXREVENUE" Visible="SalesTax='1'" Name="Tax Summary">
    <ReportRef REFID="STDREP_VATSUMMARY_AU"/>
    <!--else-->
    <!--<AccessPointItem ID="REPAPI_SALESTAXREVENUE" Visible="SalesTax='1'" Name="Tax Revenue Summary">-->
		<!--<ReportRef REFID="STDREP_SALESTAXREVENUE"/>-->
    <!--endif-->
		<Parameter Name="Suppliers &amp; Payables" Data="REPNAV_CAT_VENDOR"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_QBP_YTDDETAIL" Visible="PRIntegrated='1'" Name="Payroll Detail Review">
		<ReportRef REFID="STDREP_QBP_YTDDETAIL"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_CLOSINGDATE_AUDITTRAIL" Visible="Features.ACB_ClosingDateAuditTrail='enabled'" Name="Closing Date Exception Report">
		<ReportRef REFID="STDREP_CLOSINGDATE_AUDITTRAIL"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_VOID_DELETE_CANCEL_SUMMARY" Visible="Features.RPT_VoidDeleteReports='enabled'" Name="Voided/Deleted Transactions Summary">
		<ReportRef REFID="STDREP_VOID_DELETE_CANCEL_SUMMARY"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_VOID_DELETE_CANCEL" Visible="Features.RPT_VoidDeleteReports='enabled'" Name="Voided/Deleted Transactions Detail">
		<ReportRef REFID="STDREP_VOID_DELETE_CANCEL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_RECON_DISCREP" Visible="true" Name="Reconciliation Discrepancy">
		<ReportRef REFID="STDREP_RECON_DISCREP"/>
	</AccessPointItem>

	<!-- Depends on if feautre is ON (correct SKU) and if Sales Order Pref. is ON -->
	<AccessPointItem ID="REPAPI_INV_SALESORDERS_BY_CUST" Visible="Features.SOT_SalesOrderTracking='enabled' AND SalesOrders='1'" Name="Open Sales Orders by Customer">
		<ReportRef REFID="STDREP_INV_SALESORDERS_BY_CUST"/>
		<Parameter Name="Sales" Data="REPNAV_CAT_SALES" /> 
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PANDL_UNCLASSIFIED_SMRY" Visible="Features.RPT_PnLUnclassifiedReport='enabled'" Name="Unclassified">
		<ReportRef REFID="STDREP_PANDL_UNCLASSIFIED_SMRY"/>
		<!--TEMP -->
		<Parameter Name="Sales" Data="REPNAV_CAT_SALES" /> 
	</AccessPointItem>

	<!-- Payroll, show is HR organizer is installed -->
	<AccessPointItem ID="REPAPI_LIST_HR_HIRE" Visible="HrOrganizerEnabled='1'" Name="New Hire List">
		<ReportRef REFID="STDREP_LIST_HR_HIRE"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_HR_TERMINATION" Visible="HrOrganizerEnabled='1'" Name="Terminated Employees List">
		<ReportRef REFID="STDREP_LIST_HR_TERMINATION"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_HR_EMERGENCY" Visible="HrOrganizerEnabled='1'" Name="Emergency Contact List">
		<ReportRef REFID="STDREP_LIST_HR_EMERGENCY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_EMPLOYEE_TIMEOFF" Visible="PRIntegrated='1'" Name="Paid Time Off List">
		<ReportRef REFID="STDREP_LIST_EMPLOYEE_TIMEOFF"/>
	</AccessPointItem>

	<!-- Depends on SKU and Pref -->
	<AccessPointItem ID="REPAPI_INV_SALESORDERS_BY_ITEM" Visible="Features.SOT_SalesOrderTracking='enabled' AND SalesOrders='1'" Name="Open Sales Orders by Item">
		<ReportRef REFID="STDREP_INV_SALESORDERS_BY_ITEM"/>
	</AccessPointItem>


<!-- ifdef INTL_AU -->
  <AccessPointItem ID="REPAPI_PENDING_BUILDS" Visible="Features.UK_AUBasicFeatureRemoval='disabled'" Name="Pending Builds">
<!-- else -->
<!--   <AccessPointItem ID="REPAPI_PENDING_BUILDS" Visible="true" Name="Pending Builds"> -->
<!-- endif -->
		<ReportRef REFID="STDREP_PENDING_BUILDS"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_UNASSIGNED_JOB_EXPENSES" Visible="Features.RPT_ContractorStandardReports='enabled'" Name="Expenses Not Assigned to Jobs">
		<ReportRef REFID="STDREP_UNASSIGNED_JOB_EXPENSES"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_TEJ_COSTTOCOMPLETE_SUMMARY" Visible="Estimating='1'" Name="Cost to Complete by Job Summary">
		<ReportRef REFID="STDREP_TEJ_COSTTOCOMPLETE_SUMMARY"/>
	</AccessPointItem>
	
	<AccessPointItem ID="REPAPI_TEJ_COSTTOCOMPLETE_DETAIL" Visible="Estimating='1'" Name="Cost to Complete by Job Detail">
		<ReportRef REFID="STDREP_TEJ_COSTTOCOMPLETE_DETAIL"/>
	</AccessPointItem>
	
	<AccessPointItem ID="REPAPI_LIST_JOB_STATUS" Visible="true" Name="Job Status">
		<ReportRef REFID="STDREP_LIST_JOB_STATUS"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_JOBCOSTS_BY_VENDOR" Visible="true" Name="Job Costs by Supplier &amp; Job Detail">
		<ReportRef REFID="STDREP_JOBCOSTS_BY_VENDOR"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_JOBCOSTS_DETAIL" Visible="Features.RPT_ContractorStandardReports='enabled'" Name="Job Costs Detail">
		<ReportRef REFID="STDREP_JOBCOSTS_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_UNPAIDBILLS_BY_JOB" Visible="Features.RPT_ContractorStandardReports='enabled'" Name="Unpaid Bills by Job">
		<ReportRef REFID="STDREP_UNPAIDBILLS_BY_JOB"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_UNPAIDJOBBILLS_BY_VENDOR" Visible="Features.RPT_ContractorStandardReports='enabled'" Name="Unpaid Job Bills by Supplier">
		<ReportRef REFID="STDREP_UNPAIDJOBBILLS_BY_VENDOR"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_OPENPURCHASEORDERS_BY_VENDOR" Visible="Inventory='1'" Name="By Supplier">
		<ReportRef REFID="STDREP_OPENPURCHASEORDERS_BY_VENDOR"/>
	</AccessPointItem>

	<!-- Amittal: Duplicating to solve name problem -->
	<AccessPointItem ID="REPAPI_RETAIL_OPENPURCHASEORDERS_BY_VENDOR" Visible="Inventory='1'" Name="Open Purchase Orders by Supplier">
		<ReportRef REFID="STDREP_OPENPURCHASEORDERS_BY_VENDOR"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_OPENPURCHASEORDERS_BY_VENDORDETAIL" Visible="Inventory='1'" Name="By Supplier Detail">
		<ReportRef REFID="STDREP_OPENPURCHASEORDERS_BY_VENDORDETAIL"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_LIST_CERTIFIED_PAYROLL" Visible="true" Name="Certified Payroll - Box 1 Employee 
	Information">
		<ReportRef REFID="STDREP_LIST_CERTIFIED_PAYROLL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_VENDOR_ACCOUNTINFORMATION" Visible="true" Name="Supplier Account Information">
		<ReportRef REFID="STDREP_LIST_VENDOR_ACCOUNTINFORMATION"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_CUSTOMER_ACCOUNTINFORMATION" Visible="true" Name="Customer Account Information">
		<ReportRef REFID="STDREP_LIST_CUSTOMER_ACCOUNTINFORMATION"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PANDL_BUDGET_OVERVIEW" Visible="true" Name="Budget Overview">
		<ReportRef REFID="STDREP_PANDL_BUDGET_OVERVIEW"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PANDL_BUDGET_VS_ACTUAL" Visible="true" Name="Budget vs. Actual">
		<ReportRef REFID="STDREP_PANDL_BUDGET_VS_ACTUAL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PANDL_BUDGET_COMPARISON" Visible="Features.PRO_LegacyFeatures='enabled'" Name="Profit &amp; Loss Budget Performance">
		<ReportRef REFID="STDREP_PANDL_BUDGET_COMPARISON"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_FORECAST" Visible="Features.BUD_AdvancedForecast='enabled'" Name="Forecast Overview">
		<ReportRef REFID="STDREP_FORECAST"/>
		<Parameter Name="Budgets &amp; Forecasts" Data="REPNAV_CAT_PLANNING" /> 
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PANDL_FORECAST" Visible="Features.BUD_AdvancedForecast='enabled'" Name="Forecast vs. Actual">
		<ReportRef REFID="STDREP_PANDL_FORECAST"/>
	</AccessPointItem>

	<!-- This report replaces STDREP_LIST_ACCOUNT_INCOMETAX is RPT_IncomeTaxPrepReport is enabled, 
		so we will turn STDREP_LIST_ACCOUNT_INCOMETAX is off. -->
	<AccessPointItem ID="REPAPI_INCOMETAX_PREP" Visible="Features.RPT_IncomeTaxPrepReport='enabled'" Name="Preparation">
		<ReportRef REFID="STDREP_INCOMETAX_PREP"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LAST_RECONBOTH" Visible="true" Name="Previous Reconciliation">
		<ReportRef REFID="STDREP_LAST_RECONBOTH"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_MWD_SALES_VOLUME_BY_CUSTOMER" Visible="true" Name="Volume by Customer">
		<ReportRef REFID="STDREP_MWD_SALES_VOLUME_BY_CUSTOMER"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_MWD_SALES_BY_PRODUCT" Visible="true" Name="By Product">
		<ReportRef REFID="STDREP_MWD_SALES_BY_PRODUCT"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_MWD_SALES_BY_CUSTOMERTYPE" Visible="true" Name="By Customer Type">
		<ReportRef REFID="STDREP_MWD_SALES_BY_CUSTOMERTYPE"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_MWD_PURCHASEORDER_BYITEM" Visible="Inventory='1'" Name="Open Purchase Orders by Item">
		<ReportRef REFID="STDREP_MWD_PURCHASEORDER_BYITEM"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_MWD_SALES_BYCLASSANDITEMTYPE" Visible="true" Name="By Class &amp; Item Type">
		<ReportRef REFID="STDREP_MWD_SALES_BYCLASSANDITEMTYPE"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_MWD_INVENTORYREORDER_BYVENDOR" Visible="Inventory='1'" Name="Inventory Reorder by Supplier">
		<ReportRef REFID="STDREP_MWD_INVENTORYREORDER_BYVENDOR"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_PROJECTSTATUS" Visible="true" Name="Project Status">
		<ReportRef REFID="STDREP_LIST_PROJECTSTATUS"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_PROJECTCOSTS_DETAIL" Visible="Features.RPT_ProfessionalStandardReports='enabled'" Name="Project Costs Detail">
		<ReportRef REFID="STDREP_PROJECTCOSTS_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_UNBILLED_EXPENSES_PROJECT" Visible="true" Name="Unbilled Expenses by Project">
		<ReportRef REFID="STDREP_UNBILLED_EXPENSES_PROJECT"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_UNASSIGNED_PROJECT_EXPENSES" Visible="Features.RPT_ProfessionalStandardReports='enabled'" Name="Expenses Not Assigned to Projects">
		<ReportRef REFID="STDREP_UNASSIGNED_PROJECT_EXPENSES"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_LIST_PROJECTCONTACT" Visible="true" Name="Project Contact List">
		<ReportRef REFID="STDREP_LIST_PROJECTCONTACT"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_OPENBALANCES_CUSTOMER" Visible="true" Name="Open Balances by Customer/Project">
		<ReportRef REFID="STDREP_OPENBALANCES_CUSTOMER"/>
	</AccessPointItem>


  <AccessPointItem ID="REPAPI_ARAGING_DETAIL_CLASS" Visible="true" Name="A/R Aging Detail by Class">
    <ReportRef REFID="STDREP_ARAGING_DETAIL_CLASS"/>
  </AccessPointItem>
  
 
	<AccessPointItem ID="REPAPI_RETAIL_PNL_MONTHLY_COMPARISON" Visible="true" Name="Profit &amp; Loss Monthly Comparison">
		<ReportRef REFID="STDREP_RETAIL_PNL_MONTHLY_COMPARISON"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_RETAIL_BS_MONTHLY_COMPARISON" Visible="true" Name="Balance Sheet Monthly Comparison">
		<ReportRef REFID="STDREP_RETAIL_BS_MONTHLY_COMPARISON"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_RETAIL_GROSSMARGIN_BY_ITEM" Visible="Inventory='1'" Name="Gross Margin by Inventory Item">
		<ReportRef REFID="STDREP_RETAIL_GROSSMARGIN_BY_ITEM"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_RETAIL_CUSTPMT_BYPMTITEM" Visible="true" Name="Customer Payments by Payment Item">
		<ReportRef REFID="STDREP_RETAIL_CUSTPMT_BYPMTITEM"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_RETAIL_BILLS_BY_DUEDATE" Visible="true" Name="Bills by Due Date">
		<ReportRef REFID="STDREP_RETAIL_BILLS_BY_DUEDATE"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_RETAIL_MONTHLY_SALES_BY_CUST" Visible="true" Name="Monthly Sales by Customer">
		<ReportRef REFID="STDREP_RETAIL_MONTHLY_SALES_BY_CUST"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_RETAIL_VNDR_BY_PURCHASE_VOL" Visible="true" Name="Purchase Volume by Supplier">
		<ReportRef REFID="STDREP_RETAIL_VNDR_BY_PURCHASE_VOL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_RETAIL_VNDR_RETURNS_SMRY" Visible="true" Name="Supplier Returns Summary">
		<ReportRef REFID="STDREP_RETAIL_VNDR_RETURNS_SMRY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_RETAIL_VNDR_RETURNS_DETAIL" Visible="true" Name="Supplier Returns Detail">
		<ReportRef REFID="STDREP_RETAIL_VNDR_RETURNS_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_ADJUSTED_TRIAL_BALANCE" Visible="Features.GJE_AdjustingJournalEntries='enabled'" Name="Adjusted Trial Balance">
		<ReportRef REFID="STDREP_ADJUSTED_TRIAL_BALANCE"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_ADJUSTING_JOURNAL_ENTRIES" Visible="Features.GJE_AdjustingJournalEntries='enabled'" Name="Adjusting Journal Entries">
		<ReportRef REFID="STDREP_ADJUSTING_JOURNAL_ENTRIES"/>
	</AccessPointItem>

  <!-- ifdef INTL_AU -->
  <AccessPointItem ID="REPAPI_ADT_JOURNAL_REPORT" Visible="true" Name="ADT Journal">
    <ReportRef REFID="STDREP_ADT_JOURNAL_REPORT"/>
  </AccessPointItem>
  <!-- endif -->

<!-- ifdef INTL_AU -->
  <AccessPointItem ID="REPAPI_FIXED_ASSET_LIST" Visible="Features.UK_AUBasicFeatureRemoval='disabled'" Name="Fixed Asset Listing">
    <!-- else -->
<!--	<AccessPointItem ID="REPAPI_FIXED_ASSET_LIST" Visible="true" Name="Fixed Asset Listing"> -->
<!-- endif -->
		<ReportRef REFID="STDREP_FIXED_ASSET_LIST"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_MILEAGE_BY_VEHICLE_SUMMARY" Visible="true" Name="By Vehicle Summary">
		<ReportRef REFID="STDREP_MILEAGE_BY_VEHICLE_SUMMARY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_MILEAGE_BY_VEHICLE_DETAIL" Visible="true" Name="By Vehicle Detail">
		<ReportRef REFID="STDREP_MILEAGE_BY_VEHICLE_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_MILEAGE_BY_JOB_SUMMARY" Visible="true" Name="By Job Summary">
		<ReportRef REFID="STDREP_MILEAGE_BY_JOB_SUMMARY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_MILEAGE_BY_JOB_DETAIL" Visible="true" Name="By Job Detail">
		<ReportRef REFID="STDREP_MILEAGE_BY_JOB_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_WORKERSCOMP_SUMMARY" Visible="WorkersCompensationReportsAllowed='1' AND PRIntegrated='1'" Name="Workers Comp Summary">
		<ReportRef REFID="STDREP_WORKERSCOMP_SUMMARY"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_WORKERSCOMP_SUMMARY_EE" Visible="WorkersCompensationReportsAllowed='1' AND PRIntegrated='1'" Name="Workers Comp by Code &amp; Employee">
		<ReportRef REFID="STDREP_WORKERSCOMP_SUMMARY_EE"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_WORKERSCOMP_SUMMARY_JOB" Visible="WorkersCompensationReportsAllowed='1' AND PRIntegrated='1'" Name="Workers Comp by Job Summary">
		<ReportRef REFID="STDREP_WORKERSCOMP_SUMMARY_JOB"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_WORKERSCOMP_DETAIL" Visible="WorkersCompensationReportsAllowed='1' AND PRIntegrated='1'" Name="Workers Comp Detail">
		<ReportRef REFID="STDREP_WORKERSCOMP_DETAIL"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_WORKERSCOMP_LIST" Visible="WorkersCompensationReportsAllowed='1' AND PRIntegrated='1'" Name="Workers Comp Listing">
		<ReportRef REFID="STDREP_WORKERSCOMP_LIST"/>
	</AccessPointItem>


	<AccessPointItem ID="REPAPI_JOBCOSTS_BY_VENDORJOB_SMRY" Visible="true" Name="Job Costs by Supplier &amp; Job Summary">
		<ReportRef REFID="STDREP_JOBCOSTS_BY_VENDORJOB_SMRY"/>
	</AccessPointItem>
	
	<AccessPointItem ID="REPAPI_JOBCOSTS_BY_JOBVENDOR_SMRY" Visible="true" Name="Job Costs by Job &amp; Supplier Summary">
		<ReportRef REFID="STDREP_JOBCOSTS_BY_JOBVENDOR_SMRY"/>
	</AccessPointItem>
	
	<AccessPointItem ID="REPAPI_JOBCOSTS_BY_JOBVENDOR_DETAIL" Visible="true" Name="Job Costs by Job &amp; Supplier Detail">
		<ReportRef REFID="STDREP_JOBCOSTS_BY_JOBVENDOR_DETAIL"/>
	</AccessPointItem>
	
	<AccessPointItem ID="REPAPI_NONPROFIT_BIGGEST_DONORS" Visible="true" Name="Biggest Donors/Grants">
		<ReportRef REFID="STDREP_NONPROFIT_BIGGEST_DONORS"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_NONPROFIT_DONOR_CONTRIBUTION_SUMMARY" Visible="true" Name="Donor Contribution Summary">
		<ReportRef REFID="STDREP_NONPROFIT_DONOR_CONTRIBUTION_SUMMARY"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_NONPROFIT_BUDGET_VS_ACTUAL_BY_DONORS" Visible="true" Name="Budget vs. Actual by Donors/Grants">
		<ReportRef REFID="STDREP_NONPROFIT_BUDGET_VS_ACTUAL_BY_DONORS"/>
	</AccessPointItem>
 
	<AccessPointItem ID="REPAPI_NONPROFIT_BUDGET_VS_ACTUAL_BY_PROGRAMS" Visible="true" Name="Budget vs. Actual by Programs/Projects">
		<ReportRef REFID="STDREP_NONPROFIT_BUDGET_VS_ACTUAL_BY_PROGRAMS"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_NONPROFIT_DONORS" Visible="true" Name="Donors/Grants Report">
		<ReportRef REFID="STDREP_NONPROFIT_DONORS"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_NONPROFIT_PROGRAMS" Visible="true" Name="Programs/Projects Report">
		<ReportRef REFID="STDREP_NONPROFIT_PROGRAMS"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_NONPROFIT_FINANCIAL_INCOME" Visible="true" Name="Statement of Financial Income and Expense">
		<ReportRef REFID="STDREP_NONPROFIT_FINANCIAL_INCOME"/>
	</AccessPointItem>

	<AccessPointItem ID="REPAPI_NONPROFIT_FINANCIAL_POSITION" Visible="true" Name="Statement of Financial Position">
		<ReportRef REFID="STDREP_NONPROFIT_FINANCIAL_POSITION"/>
	</AccessPointItem>
<!-- ifndef INTL_AU mantis 19240 -->
    <!-- <AccessPointItem ID="REPAPI_NONPROFIT_FUNCTIONAL_EXPENSES" Visible="true" Name="Statement of Functional Expenses (990)">
    <ReportRef REFID="STDREP_NONPROFIT_FUNCTIONAL_EXPENSES"/>
  </AccessPointItem> -->
<!-- endif-->

  <AccessPointItem ID="REPAPI_LIST_UOM_SETS" Visible="UnitOfMeasureAdvanced='1'" Name="Unit of Measure Set Listing">
    <ReportRef REFID="STDREP_LIST_UOM_SETS"/>
  </AccessPointItem>

  <AccessPointItem ID="REPAPI_LIST_UOM_UNITS" Visible="UnitOfMeasureAdvanced='1'" Name="U/M Sets with Related Units">
    <ReportRef REFID="STDREP_LIST_UOM_UNITS"/>
  </AccessPointItem>

  <AccessPointItem ID="REPAPI_LIST_ITEM_BY_UOM_SET" Visible="UnitOfMeasureAdvanced='1' OR UnitOfMeasureSimple='1'" Name="Items with Units of Measure">
    <ReportRef REFID="STDREP_LIST_ITEM_BY_UOM_SET"/>
  </AccessPointItem>

  <!-- =================================== REPORT NAVIGATOR ===================================== -->	
	
	<AccessPointList ID="REPORTS_NAVIGATOR" Name="Reports">
	
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_FINANCIAL" Visible="true" Name="Company &amp; Financial">
				<Description>Find out how well your company is doing financially.</Description>
				
				
				<AccessPointList ID="REPNAV_SCAT_PANDL" Name="Profit &amp; Loss (income statement)">
					<AccessPointItemRef REFID="REPAPI_PANDL_STD"/>
					<AccessPointItemRef REFID="REPAPI_PANDL_ITEMIZED"/>
					<AccessPointItemRef REFID="REPAPI_PANDL_YTD"/>
					<AccessPointItemRef REFID="REPAPI_PANDL_COMP"/>
					<AccessPointItemRef REFID="REPAPI_PANDL_JOB"/>
					<AccessPointItemRef REFID="REPAPI_PANDL_CLASS"/>
					<AccessPointItemRef REFID="REPAPI_PANDL_UNCLASSIFIED_SMRY"/>
				</AccessPointList>
				
				<AccessPointList ID="REPNAV_SCAT_INCNEXP" Name="Income &amp; Expenses">
					<AccessPointItemRef REFID="REPAPI_INCCUSTSMRY"/>
					<AccessPointItemRef REFID="REPAPI_INCCUSTDETAIL"/>
					<AccessPointItemRef REFID="REPAPI_EXPVENDSMRY"/>
					<AccessPointItemRef REFID="REPAPI_EXPVENDDETAIL"/>
					<AccessPointItemRef REFID="REPAPI_GRAPHINCEXP"/>
				</AccessPointList>
								
				<AccessPointList ID="REPNAV_SCAT_BS" Name="Balance Sheet &amp; Net Worth">
          <!-- ifdef INTL_AU -->
          <AccessPointItemRef REFID="REPAPI_BS_AUSTD"/>
          <AccessPointItemRef REFID="REPAPI_BS_AUITEMIZED"/>
          <AccessPointItemRef REFID="REPAPI_BS_AUSMRY"/>
          <AccessPointItemRef REFID="REPAPI_BS_AUCOMP"/>
          <!-- endif -->
          <AccessPointItemRef REFID="REPAPI_BS_STD"/>
          <AccessPointItemRef REFID="REPAPI_BS_ITEMIZED"/>
          <AccessPointItemRef REFID="REPAPI_BS_SMRY"/>
          <AccessPointItemRef REFID="REPAPI_BS_COMP"/>
          <AccessPointItemRef REFID="REPAPI_GRAPHBALSHEET"/>
        </AccessPointList>
								
				<AccessPointList ID="REPNAV_SCAT_CASHFLOW" Name="Cash Flow">
					<AccessPointItemRef REFID="REPAPI_CASHFLOW_STD"/>
					<AccessPointItemRef REFID="REPAPI_CASHFLOW_FORECAST"/>
				</AccessPointList>
				
				<AccessPointList ID="REPNAV_RELATED_REPORTS:FINANCIAL" Name="Related Reports">
					<AccessPointItemRef REFID="REPAPI_TRANSBYACCNT"/>
					<AccessPointItemRef REFID="REPAPI_FORECAST"/>
				</AccessPointList>
		
		</AccessPointList>
		
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_CUSTOMER" Visible="true" Name="Customers &amp; Receivables">
			<Description>Find out how  much money your  customers owe and when it is due.</Description>
      <!--ifdef intl_au-->
			<AccessPointList ID="REPNAV_SCAT_ARAGING" Name="A/R Ageing (what my customers owe me and what is overdue)">
				<AccessPointItemRef REFID="REPAPI_ARAGING_SMRY"/>
				<AccessPointItemRef REFID="REPAPI_ARAGING_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_GRAPHARSUMMARY"/>
				<AccessPointItemRef REFID="REPAPI_OPENINVOICE"/>
				<AccessPointItemRef REFID="REPAPI_COLLECT"/>													
			</AccessPointList>
      <!-- else -->
      <!--   <AccessPointList ID="REPNAV_SCAT_ARAGING" Name="A/R Aging (what my customers owe me and what is overdue)">
        <AccessPointItemRef REFID="REPAPI_ARAGING_SMRY"/>
        <AccessPointItemRef REFID="REPAPI_ARAGING_DETAIL"/>
        <AccessPointItemRef REFID="REPAPI_GRAPHARSUMMARY"/>
        <AccessPointItemRef REFID="REPAPI_OPENINVOICE"/>
        <AccessPointItemRef REFID="REPAPI_COLLECT"/>
      </AccessPointList>
        -->
      <!-- end if-->
			<AccessPointList ID="REPNAV_SCAT_CUSTBAL" Name="Customer Balance">
				<AccessPointItemRef REFID="REPAPI_CUSTBALSMRY"/>					
				<AccessPointItemRef REFID="REPAPI_CUSTBALDETAIL"/>
				<AccessPointItemRef REFID="REPAPI_PROJ_BILLABLES"/>
				<AccessPointItemRef REFID="REPAPI_TRANSBYCUST"/>					
				<AccessPointItemRef REFID="REPAPI_PROCESSEDPMNTS_DETAIL"/>				
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_CUSTLIST" Name="Lists">
				<AccessPointItemRef REFID="REPAPI_LIST_CUSTOMER_PHONE"/>
				<AccessPointItemRef REFID="REPAPI_LIST_CUSTOMER_CONTACT"/>
				<AccessPointItemRef REFID="REPAPI_LIST_ITEM_PRICELIST"/>									
			</AccessPointList>
									
			<AccessPointList ID="REPNAV_RELATED_REPORTS:CUSTOMER" Name="Related Reports">
				<AccessPointItemRef REFID="REPAPI_INCCUSTSMRY"/>				
				<AccessPointItemRef REFID="REPAPI_INV_SALESORDERS_BY_CUST"/>
			</AccessPointList>
								
		</AccessPointList>
		
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_SALES" Visible="true" Name="Sales">
			
			<If test="Features.SOT_SalesOrderTracking='enabled'">
				<Description>Find sales information related to customers, items, sales reps, pending sales, and sales orders.</Description>
			</If>
			<Else>
				<!-- Else Pro or Basic -->
				<Description>Find sales information related to customers, items, sales reps, and pending sales.</Description>
			</Else>
			
			<AccessPointList ID="REPNAV_SCAT_SALESCUST" Name="Sales by Customer">
				<AccessPointItemRef REFID="REPAPI_SALESBYCUSTSMRY"/>
				<AccessPointItemRef REFID="REPAPI_SALESBYCUSTDETAIL"/>				
				<AccessPointItemRef REFID="REPAPI_PENDING_SALES"/>
				<AccessPointItemRef REFID="REPAPI_GRAPHSALESBYITEM"/>
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_SALESITEM" Name="Sales by Item">
				<AccessPointItemRef REFID="REPAPI_SALES_SMRY"/>
				<AccessPointItemRef REFID="REPAPI_SALES_ITEMIZED"/>			
			</AccessPointList>
			
			
			<AccessPointList ID="REPNAV_SCAT_SALESREP" Name="Sales by Rep">
				<AccessPointItemRef REFID="REPAPI_SALESBYREPSMRY"/>
				<AccessPointItemRef REFID="REPAPI_SALESBYREPDETAIL"/>				
			</AccessPointList>
		
			<AccessPointList ID="REPNAV_SCAT_SALESORDER" Name="Open Sales Order">
				<AccessPointItemRef REFID="REPAPI_INV_SALESORDERS_BY_CUST"/>
				<AccessPointItemRef REFID="REPAPI_INV_SALESORDERS_BY_ITEM"/>				
			</AccessPointList>
		
			
			<AccessPointList ID="REPNAV_RELATED_REPORTS:SALES" Name="Related Reports">
				<AccessPointItemRef REFID="REPAPI_SALESTAX"/>
				<AccessPointItemRef REFID="REPAPI_SALESTAXREVENUE"/>				
			</AccessPointList>
		
		</AccessPointList>
		
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_JOBS" Visible="Features.PRO_LegacyFeatures='enabled'" Name="Jobs, Time &amp; Mileage">
			<Description>Find out how well your company is doing at estimating jobs, how much time is spent on each job, and the mileage expenses for each vehicle or job.</Description>
			
			
			<AccessPointList ID="REPNAV_SCAT_JOB_PROFIT" Name="Jobs &amp; Profitability">
				<AccessPointItemRef REFID="REPAPI_TEJ_JOB_PROFIT"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_JOB_PROF_DET"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_PANDL_JOB"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_ITEM_PROFIT"/>								
				<AccessPointItemRef REFID="REPAPI_PROJ_BILLABLES"/>							
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_JOB_EST" Name="Job Estimates">
				<AccessPointItemRef REFID="REPAPI_TEJ_JOB_EST"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_JOB_EST_DET"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_PROGRESS_BILLING"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_ITEM_EST"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_ESTIMATES_BYJOB"/>
				<AccessPointItemRef REFID="REPAPI_INV_OPENPOBYJOB"/>				
			</AccessPointList>
			
			
			<AccessPointList ID="REPNAV_SCAT_TIME" Name="Time">
				<AccessPointItemRef REFID="REPAPI_TEJ_TM_JOB"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_TM_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_TM_EMP"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_TM_ITEM"/>				
			</AccessPointList>	
			
			<AccessPointList ID="REPNAV_SCAT_MILEAGE" Name="Mileage">				
				<AccessPointItemRef REFID="REPAPI_MILEAGE_BY_VEHICLE_SUMMARY"/>
				<AccessPointItemRef REFID="REPAPI_MILEAGE_BY_VEHICLE_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_MILEAGE_BY_JOB_SUMMARY"/>
				<AccessPointItemRef REFID="REPAPI_MILEAGE_BY_JOB_DETAIL"/>
			</AccessPointList>	
			
						
			<AccessPointList ID="REPNAV_RELATED_REPORTS:JOBS" Name="Related Reports">
				<AccessPointItemRef REFID="REPAPI_LIST_ITEM_PRICELIST"/>
			</AccessPointList>
		
			
		</AccessPointList>
		
	
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_VENDOR" Visible="true" Name="Suppliers &amp; Payables">
			<Description>Find out how much money your company owes and how much of it is overdue.</Description>
      <!--ifdef intl_Au-->
			<AccessPointList ID="REPNAV_SCAT_APAGING" Name="A/P Ageing (due and overdue bills)">
					<AccessPointItemRef REFID="REPAPI_APAGING_SMRY"/>
					<AccessPointItemRef REFID="REPAPI_APAGING_DETAIL"/>	
					<AccessPointItemRef REFID="REPAPI_GRAPHAPSUMMARY"/>								
			</AccessPointList>
      <!-- else -->
     <!--  <AccessPointList ID="REPNAV_SCAT_APAGING" Name="A/P Aging (due and overdue bills)">
        <AccessPointItemRef REFID="REPAPI_APAGING_SMRY"/>
        <AccessPointItemRef REFID="REPAPI_APAGING_DETAIL"/>
        <AccessPointItemRef REFID="REPAPI_GRAPHAPSUMMARY"/>
      </AccessPointList>
      -->
      <!-- endif-->
      
			<AccessPointList ID="REPNAV_SCAT_VENDBAL" Name="Supplier Balances">
					<AccessPointItemRef REFID="REPAPI_VENDBALSMRY"/>
					<AccessPointItemRef REFID="REPAPI_VENDBALDETAIL"/>
					<AccessPointItemRef REFID="REPAPI_OPENBILL"/>					
					<AccessPointItemRef REFID="REPAPI_TRANSBYVENDOR"/>					
			</AccessPointList>
		
		
			<!-- AccessPointList ID="REPNAV_SCAT_1099" Name="1099">									
					<AccessPointItemRef REFID="REPAPI_1099"/>
					<AccessPointItemRef REFID="REPAPI_1099DETAIL"/>					
			</AccessPointList -->
		
		
			<AccessPointList ID="REPNAV_SCAT_SALESTAX" Name="Tax">														
					<AccessPointItemRef REFID="REPAPI_SALESTAX"/>
					<AccessPointItemRef REFID="REPAPI_SALESTAXREVENUE"/>										
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_VEND_LIST_V1" Name="Lists">					
					<AccessPointItemRef REFID="REPAPI_LIST_VENDOR_PHONE"/>
					<AccessPointItemRef REFID="REPAPI_LIST_VENDOR_CONTACT"/>					
			</AccessPointList>
		
			<AccessPointList ID="REPNAV_RELATED_REPORTS:VENDOR" Name="Related Reports">
				<AccessPointItemRef REFID="REPAPI_EXPVENDSMRY"/>
				<AccessPointItemRef REFID="REPAPI_PURCHBYVENDSMRY"/>							
			</AccessPointList>
		
		</AccessPointList>
		
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_PURCHASES" Visible="Inventory='1'" Name="Purchases">
			<Description>Find information about purchases and open purchase orders.</Description>
		
			
			<AccessPointList ID="REPNAV_SCAT_PURCHASES_VEND" Name="Purchases by Supplier">
				<AccessPointItemRef REFID="REPAPI_PURCHBYVENDSMRY"/>
				<AccessPointItemRef REFID="REPAPI_PURCHBYVENDDETAIL"/>				
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_PURCHASES_ITEM" Name="Purchases by Item">				
				<AccessPointItemRef REFID="REPAPI_PURCH_SMRY"/>
				<AccessPointItemRef REFID="REPAPI_PURCH_ITEMIZED"/>
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_PO" Name="Open Purchase Orders">				
				<AccessPointItemRef REFID="REPAPI_OPENPO"/>
				<AccessPointItemRef REFID="REPAPI_INV_OPENPOBYJOB"/>
			</AccessPointList>
		
		
			<AccessPointList ID="REPNAV_RELATED_REPORTS:PURCHASES" Name="Related Reports">
				<AccessPointItemRef REFID="REPAPI_LIST_VENDOR_CONTACT"/>
				<AccessPointItemRef REFID="REPAPI_EXPVENDSMRY"/>
			</AccessPointList>
		
		</AccessPointList>
		
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_INVENTORY" Visible="Inventory='1'" Name="Inventory">
			<Description>Find information about inventory value, stock status, and pending builds, including a worksheet for checking your physical inventory.</Description>


			<AccessPointList ID="REPNAV_SCAT_INV_VAL" Name="Inventory Valuation">
				<AccessPointItemRef REFID="REPAPI_INV_VALSMRY"/>
				<AccessPointItemRef REFID="REPAPI_INV_VALDETAIL"/>
			</AccessPointList>

<!-- ifdef INTL_AU -->
      <AccessPointList ID="REPNAV_SCAT_INV_STOCK" Name="Inventory Status">
<!-- else -->
<!--       <AccessPointList ID="REPNAV_SCAT_INV_STOCK" Name="Inventory Stock Status"> -->
<!-- endif -->
				<AccessPointItemRef REFID="REPAPI_INV_STOCKBYITEM"/>
				<AccessPointItemRef REFID="REPAPI_INV_STOCKBYVEND"/>
				<AccessPointItemRef REFID="REPAPI_INV_PHYSWKSHT"/>
				<AccessPointItemRef REFID="REPAPI_PENDING_BUILDS"/>
			</AccessPointList>
		
			<AccessPointList ID="REPNAV_RELATED_REPORTS:INVENTORY" Name="Related Reports">
				<AccessPointItemRef REFID="REPAPI_OPENPO"/>
			</AccessPointList>
		
		
		</AccessPointList>
		
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_PAYROLL" Visible="true" Name="Employees &amp; Payroll">
			<Description>Find information about your employees, payroll, and payroll-related expenses.</Description>
			
			<AccessPointList ID="REPNAV_SCAT_PAYROLL" Name="Payroll">
				<AccessPointItemRef REFID="REPAPI_QBP_SMRY"/>
				<AccessPointItemRef REFID="REPAPI_QBP_ITEMDETAIL"/>
				<AccessPointItemRef REFID="REPAPI_QBP_YTDDETAIL"/>				
				<AccessPointItemRef REFID="REPAPI_QBP_TRANS"/>
				<AccessPointItemRef REFID="REPAPI_QBP_TRANSJOURNAL"/>
				<AccessPointItemRef REFID="REPAPI_QBP_LIAB"/>
				<AccessPointItemRef REFID="REPAPI_LIST_PAYROLLITEM_DETAIL"/>
        <AccessPointItemRef REFID="STDREP_AU_PAYROLL_TOTALS_SMRY_RPT"/>		
        <AccessPointItemRef REFID="REPAPI_QBP_EMPJOURNAL"/>
				<AccessPointItemRef REFID="REPAPI_QBP_EMPSTATETAXESDETAIL"/>
        <AccessPointItemRef REFID="REPAPI_SUPER_REPORT_BY_EMPLOYEE" />
			</AccessPointList>
		
			<AccessPointList ID="REPNAV_SCAT_EMPLOYEE" Name="Employee">				
				<AccessPointItemRef REFID="REPAPI_LIST_EMPLOYEE_CONTACT"/>
        <!-- INTL_AU remove <AccessPointItemRef REFID="REPAPI_LIST_EMPLOYEE_WITHHOLDING"/>		 -->		
				<AccessPointItemRef REFID="REPAPI_LIST_EMPLOYEE_TIMEOFF"/>
			</AccessPointList>
		
			<AccessPointList ID="REPNAV_SCAT_EMP_ORG" Name="Employee Organizer">				
				<AccessPointItemRef REFID="REPAPI_LIST_HR_EMERGENCY"/>
				<AccessPointItemRef REFID="REPAPI_LIST_HR_HIRE"/>
				<AccessPointItemRef REFID="REPAPI_LIST_HR_TERMINATION"/>				
			</AccessPointList>
					
			<AccessPointList ID="REPNAV_SCAT_WORKERSCOMP" Name="Workers Compensation">				
				<AccessPointItemRef REFID="REPAPI_WORKERSCOMP_SUMMARY"/>
				<AccessPointItemRef REFID="REPAPI_WORKERSCOMP_SUMMARY_EE"/>
				<AccessPointItemRef REFID="REPAPI_WORKERSCOMP_SUMMARY_JOB"/>
				<AccessPointItemRef REFID="REPAPI_WORKERSCOMP_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_WORKERSCOMP_LIST"/>
			</AccessPointList>

			<AccessPointList ID="REPNAV_RELATED_REPORTS:PAYROLL" Name="Related Reports">
				<AccessPointItemRef REFID="REPAPI_CHECKDETAIL"/>
				<AccessPointItemRef REFID="REPAPI_GRAPHINCEXP"/>
			</AccessPointList>
		
		
		</AccessPointList>
		
		
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_BANKING" Visible="true" Name="Banking">
			<Description>Find information about your banking transactions.</Description>
		
			<AccessPointList ID="REPNAV_SCAT_BANKING" Name="Banking">
				<AccessPointItemRef REFID="REPAPI_DEPOSITDETAIL"/>
				<AccessPointItemRef REFID="REPAPI_CHECKDETAIL"/>
				<AccessPointItemRef REFID="REPAPI_MISSINGCHECK"/>
				<AccessPointItemRef REFID="REPAPI_RECON_DISCREP"/>
				<AccessPointItemRef REFID="REPAPI_LAST_RECONBOTH"/>
        <!--ifdef INTL_AU ShiY -->
        <AccessPointItemRef REFID="REPAPI_BANK_ONLINE"/>
        <!--End INTL_AU ShiY-->
			</AccessPointList>
		
			<AccessPointList ID="REPNAV_RELATED_REPORTS:BANKING" Name="Related Reports">
				<AccessPointItemRef REFID="REPAPI_TRANSBYACCNT"/>
				<AccessPointItemRef REFID="REPAPI_GENLEDGER"/>				
			</AccessPointList>
		
		
		</AccessPointList>
		
		
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_TAXES" Visible="true" Name="Accountant &amp; Taxes">
			<Description>Find information related to accounting activities and income tax preparation.</Description>
							
			<AccessPointList ID="REPNAV_SCAT_ACCOUNTANT" Name="Accountant Only">
				<AccessPointItemRef REFID="REPAPI_ADJUSTED_TRIAL_BALANCE"/>
				<AccessPointItemRef REFID="REPAPI_ADJUSTING_JOURNAL_ENTRIES"/>				
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_ACCOUNT" Name="Account Activity">
				<AccessPointItemRef REFID="REPAPI_TRIALBAL"/>
				<AccessPointItemRef REFID="REPAPI_GENLEDGER"/>
				<AccessPointItemRef REFID="REPAPI_TRANSBYACCNT"/>
				<AccessPointItemRef REFID="REPAPI_JOURNAL"/>
				<AccessPointItemRef REFID="REPAPI_AUDITTRAIL"/>
				<AccessPointItemRef REFID="REPAPI_CLOSINGDATE_AUDITTRAIL"/>
				<AccessPointItemRef REFID="REPAPI_VOID_DELETE_CANCEL_SUMMARY"/>
				<AccessPointItemRef REFID="REPAPI_VOID_DELETE_CANCEL"/>
				<AccessPointItemRef REFID="REPAPI_TRANSBYDATE"/>				
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_ACC_LISTING" Name="Listing">
				<AccessPointItemRef REFID="REPAPI_LIST_ACCOUNT_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_FIXED_ASSET_LIST"/>				
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_INC_TAXES" Name="Income Tax">				
				<!-- Below 2 are exclusive -->
				<AccessPointItemRef REFID="REPAPI_LIST_ACCOUNT_INCOMETAX"/>
				<AccessPointItemRef REFID="REPAPI_INCOMETAX_PREP"/>
				<AccessPointItemRef REFID="REPAPI_INCOMETAX_SMRY"/>
				<AccessPointItemRef REFID="REPAPI_INCOMETAX_DETAIL"/>
			</AccessPointList>
					
			<AccessPointList ID="REPNAV_RELATED_REPORTS:TAXES" Name="Related Reports">
				<AccessPointItemRef REFID="REPAPI_SALESTAX"/>
				<AccessPointItemRef REFID="REPAPI_SALESTAXREVENUE"/>
				<!-- AccessPointItemRef REFID="REPAPI_1099"/ -->				
			</AccessPointList>
				
		</AccessPointList>
		
			
		<!-- ________________________________Category_________________________ -->	
			
		<AccessPointList ID="REPNAV_CAT_PLANNING" Visible="true" Name="Budgets">
			<If test="Features.BUD_AdvancedForecast='enabled'" Name="Budgets &amp; Forecasts" /> 
			<Description>Find out how well your company is doing in meeting its budgeted income and expenses.</Description>
		
			<AccessPointList ID="REPNAV_SCAT_BUDGETS" Name="Budgets">
				<AccessPointItemRef REFID="REPAPI_PANDL_BUDGET_OVERVIEW"/>
				<AccessPointItemRef REFID="REPAPI_PANDL_BUDGET_VS_ACTUAL"/>
				<AccessPointItemRef REFID="REPAPI_PANDL_BUDGET_COMPARISON"/>
				<AccessPointItemRef REFID="REPAPI_GRAPHBUDGET"/>							
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_FORECAST" Name="Forecasting">
				<AccessPointItemRef REFID="REPAPI_FORECAST"/>				
				<AccessPointItemRef REFID="REPAPI_PANDL_FORECAST"/>				
			</AccessPointList>
		</AccessPointList>
		
		
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_LIST" Visible="true" Name="List">
			<Description>Find lists of useful information about your company.</Description>
		
			<AccessPointList ID="REPNAV_SCAT_CUST_LIST" Name="Customer">				
				<AccessPointItemRef REFID="REPAPI_LIST_CUSTOMER_PHONE_LST"/>
				<AccessPointItemRef REFID="REPAPI_LIST_CUSTOMER_CONTACT_LST"/>				
			</AccessPointList>
				
			<AccessPointList ID="REPNAV_SCAT_VEND_LIST" Name="Supplier">
				<AccessPointItemRef REFID="REPAPI_LIST_VENDOR_PHONE_LST"/>
				<AccessPointItemRef REFID="REPAPI_LIST_VENDOR_CONTACT_LST"/>				
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_EMPL_LIST" Name="Employee">				
				<AccessPointItemRef REFID="REPAPI_LIST_EMPLOYEE_CONTACT_LST"/>				
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_OTHERNAME_LIST" Name="Other Names">
				<AccessPointItemRef REFID="REPAPI_LIST_OTHERNAME_PHONE"/>
				<AccessPointItemRef REFID="REPAPI_LIST_OTHERNAME_CONTACT"/>				
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_LISTING" Name="Listing">
				<AccessPointItemRef REFID="REPAPI_LIST_ACCOUNT_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_LIST_ITEM_PRICELIST"/>				
				<AccessPointItemRef REFID="REPAPI_LIST_ITEM_DETAIL"/>
        <AccessPointItemRef REFID="REPAPI_LIST_UOM_SETS"/>
        <AccessPointItemRef REFID="REPAPI_LIST_UOM_UNITS"/>
        <AccessPointItemRef REFID="REPAPI_LIST_ITEM_BY_UOM_SET"/>
        <AccessPointItemRef REFID="REPAPI_LIST_PAYROLLITEM_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_WORKERSCOMP_LIST"/>
				<AccessPointItemRef REFID="REPAPI_FIXED_ASSET_LIST"/>
				<AccessPointItemRef REFID="REPAPI_LIST_TERMS_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_LIST_TODO_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_LIST_MTRANS_DETAIL"/>						
			</AccessPointList>	
				
			<AccessPointList ID="REPNAV_RELATED_REPORTS:LIST" Name="Related Reports">
				<AccessPointItemRef REFID="REPAPI_TRANSBYCUST"/>
				<AccessPointItemRef REFID="REPAPI_TRANSBYVENDOR"/>
			</AccessPointList>
				
		</AccessPointList>
		
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_CONTRACTOR" Visible="Features.RPT_ContractorStandardReports='enabled'" Name="Contractor">
			<Description>Reports that are particularly useful for contractors.</Description>
		
			<AccessPointList ID="REPNAV_SCAT_JOBS_BILLS" Name="Job Costs &amp; Bills">
				<AccessPointItemRef REFID="REPAPI_LIST_JOB_STATUS"/>
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_BY_VENDORJOB_SMRY"/>
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_BY_VENDOR"/>
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_BY_JOBVENDOR_SMRY"/>
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_BY_JOBVENDOR_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_COSTTOCOMPLETE_SUMMARY"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_COSTTOCOMPLETE_DETAIL"/>				
				<AccessPointItemRef REFID="REPAPI_UNPAIDBILLS_BY_JOB"/>
				<AccessPointItemRef REFID="REPAPI_UNPAIDJOBBILLS_BY_VENDOR"/>
				<AccessPointItemRef REFID="REPAPI_UNASSIGNED_JOB_EXPENSES"/>
			</AccessPointList>
		
		
			<AccessPointList ID="REPNAV_SCAT_BILLABLE" Name="Billed/Unbilled Hours" Visible="TrackingTime='1'">
				<AccessPointItemRef REFID="REPAPI_TEJ_TMNAME_BILLABLESTATUS"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_TMNAMEJOB_BILLABLESTATUS"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_TMNAMEITEM_BILLABLESTATUS"/>
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_OPENPO" Name="Open Purchase Orders">
				<AccessPointItemRef REFID="REPAPI_OPENPURCHASEORDERS_BY_VENDOR"/>
				<AccessPointItemRef REFID="REPAPI_OPENPURCHASEORDERS_BY_VENDORDETAIL"/>				
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_CONTRACTOR_OTHER" Name="Other">
        <!-- ifndef INTL_AU -->
				<!-- <AccessPointItemRef REFID="REPAPI_LIST_CERTIFIED_PAYROLL"/> -->
        <!-- endif -->
				<AccessPointItemRef REFID="REPAPI_LIST_VENDOR_ACCOUNTINFORMATION"/>
				<AccessPointItemRef REFID="REPAPI_LIST_CUSTOMER_ACCOUNTINFORMATION"/>
			</AccessPointList>
					
		</AccessPointList>
		
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_WHOLESALE" Visible="Features.RPT_WholesaleStandardReports='enabled'" Name="Mfg &amp; Wholesale">
			<Description>Find reports that are particularly useful for manufacturers, wholesalers, and distributors.</Description>
		
			<AccessPointList ID="REPNAV_SCAT_WHOLESALE_SALES" Name="Sales">
				<AccessPointItemRef REFID="REPAPI_MWD_SALESBYREPDETAIL"/>
				<AccessPointItemRef REFID="REPAPI_MWD_SALES_BY_PRODUCT"/>
				<AccessPointItemRef REFID="REPAPI_MWD_SALES_BY_CUSTOMERTYPE"/>
				<AccessPointItemRef REFID="REPAPI_MWD_SALES_VOLUME_BY_CUSTOMER"/>
				<AccessPointItemRef REFID="REPAPI_MWD_SALES_BYCLASSANDITEMTYPE"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_MWD_PROFITABILITY_PRODUCT"/>						
			</AccessPointList>

			<AccessPointList ID="REPNAV_SCAT_WHOLESALE_Orders" Name="Open Orders">
				<AccessPointItemRef REFID="REPAPI_INV_SALESORDERS_BY_ITEM"/>
				<AccessPointItemRef REFID="REPAPI_INV_SALESORDERS_BY_CUST"/>
				<AccessPointItemRef REFID="REPAPI_MWD_PURCHASEORDER_BYITEM"/>
			</AccessPointList>


			<AccessPointList ID="REPNAV_SCAT_WHOLESALE_INV" Name="Inventory">
				<AccessPointItemRef REFID="REPAPI_MWD_INVENTORYREORDER_BYVENDOR"/>
				<AccessPointItemRef REFID="REPAPI_INV_PHYSWKSHT"/>				
			</AccessPointList>
			
		</AccessPointList>
		
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_PROFESSIONAL" Visible="Features.RPT_ProfessionalStandardReports='enabled'" Name="Professional Services">
			<Description>Find reports that are particularly useful for professional services firms.</Description>
		
			<AccessPointList ID="REPNAV_SCAT_PS_PROJ" Name="Projects">
				<AccessPointItemRef REFID="REPAPI_PROJECTCOSTS_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_UNBILLED_EXPENSES_PROJECT"/>
				<AccessPointItemRef REFID="REPAPI_UNASSIGNED_PROJECT_EXPENSES"/>
				<AccessPointItemRef REFID="REPAPI_BILLEDVSPROPOSAL_PROJECT"/>
				<AccessPointItemRef REFID="REPAPI_OPENBALANCES_CUSTOMER"/>
				<AccessPointItemRef REFID="REPAPI_ARAGING_DETAIL_CLASS"/>
				<AccessPointItemRef REFID="REPAPI_LIST_PROJECTSTATUS"/>
				<AccessPointItemRef REFID="REPAPI_LIST_PROJECTCONTACT"/>
			</AccessPointList>
						
			<AccessPointList ID="REPNAV_SCAT_PS_BILLABLE" Name="Billed/Unbilled Hours" Visible="TrackingTime='1'">
				<AccessPointItemRef REFID="REPAPI_TEJ_TMNAME_BILLABLESTATUS"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_PROSVC_TMNAMEPROJECT"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_TMNAMEITEM_BILLABLESTATUS"/>				
			</AccessPointList>

			<AccessPointList ID="REPNAV_SCAT_PS_JOBS_COSTS_BILLS" Name="Job Costs &amp; Bills">
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_BY_VENDORJOB_SMRY"/>
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_BY_VENDOR"/>
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_BY_JOBVENDOR_SMRY"/>
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_BY_JOBVENDOR_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_COSTTOCOMPLETE_SUMMARY"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_COSTTOCOMPLETE_DETAIL"/>
			</AccessPointList>
		</AccessPointList>
	
		<!-- ________________________________Category_________________________ -->
		
		<AccessPointList ID="REPNAV_CAT_JOBCOSTING" Visible="(Features.RPT_ContractorStandardReports='enabled' OR Features.RPT_ProfessionalStandardReports='enabled') AND (Features.RPT_AccountONLYReports!='enabled')" Name="Job Costing">
			<If test="Features.RPT_ProfessionalStandardReports='enabled'" Name="Project Costing" />
			<If test="Features.RPT_ProfessionalStandardReports='enabled'">
				<Description>Find out how much money you've made and spent on your projects (jobs), plus how well your proposals (estimates) are comparing to your actuals.</Description>
			</If>
			<Else>
				<!-- It's Contractor -->
				<Description>Find out how much money you've made and spent on your jobs, plus how well you are estimating jobs.</Description>	
			</Else>					
			<AccessPointList ID="REPNAV_SCAT_JOB_PROFITABILITY" Name="Jobs &amp; Profitability">
				<AccessPointItemRef REFID="REPAPI_TEJ_JOB_PROFIT"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_JOB_PROF_DET"/>	
				<AccessPointItemRef REFID="REPAPI_TEJ_ITEM_PROFIT"/>	
				<AccessPointItemRef REFID="REPAPI_TEJ_PANDL_JOB"/>	
			</AccessPointList>

			<AccessPointList ID="REPNAV_SCAT_JOB_ESTIMATES" Name="Job Estimates">
				<AccessPointItemRef REFID="REPAPI_TEJ_JOB_EST"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_JOB_EST_DET"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_PROGRESS_BILLING"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_ITEM_EST"/>
			</AccessPointList>

			<AccessPointList ID="REPNAV_SCAT_JOBS_COSTS_BILLS" Name="Job Costs &amp; Bills">
				<AccessPointItemRef REFID="REPAPI_TEJ_COSTTOCOMPLETE_SUMMARY"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_COSTTOCOMPLETE_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_BY_VENDORJOB_SMRY"/>
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_BY_VENDOR"/>
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_BY_JOBVENDOR_SMRY"/>
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_BY_JOBVENDOR_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_PROJECTCOSTS_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_JOBCOSTS_DETAIL"/>	
				<AccessPointItemRef REFID="REPAPI_UNPAIDBILLS_BY_JOB"/>
				<AccessPointItemRef REFID="REPAPI_UNPAIDJOBBILLS_BY_VENDOR"/>
				<AccessPointItemRef REFID="REPAPI_UNASSIGNED_PROJECT_EXPENSES"/>
				<AccessPointItemRef REFID="REPAPI_UNASSIGNED_JOB_EXPENSES"/>
			</AccessPointList>

		</AccessPointList>
		
		
		<!-- ________________________________Category_________________________ -->
	
		<AccessPointList ID="REPNAV_CAT_RETAIL" Visible="Features.RPT_RetailStandardReports='enabled'" Name="Retail">
			<Description>Find reports that are particularly useful for retail businesses.</Description>
		
			<AccessPointList ID="REPNAV_SCAT_RETAIL_COMP" Name="Company">
				<AccessPointItemRef REFID="REPAPI_RETAIL_PNL_MONTHLY_COMPARISON"/>
				<AccessPointItemRef REFID="REPAPI_RETAIL_BS_MONTHLY_COMPARISON"/>				
			</AccessPointList>
				
			<AccessPointList ID="REPNAV_SCAT_RETAIL_SALES" Name="Sales">
				<AccessPointItemRef REFID="REPAPI_GRAPHSALESBYITEM"/>
				<AccessPointItemRef REFID="REPAPI_RETAIL_MONTHLY_SALES_BY_CUST"/>
				<AccessPointItemRef REFID="REPAPI_RETAIL_GROSSMARGIN_BY_ITEM"/>				
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_RETAIL_CUST" Name="Customer">
				<AccessPointItemRef REFID="REPAPI_RETAIL_CUSTPMT_BYPMTITEM"/>
				<AccessPointItemRef REFID="REPAPI_TEJ_RETAIL_ESTIMATES_BY_CUST"/>				
			</AccessPointList>
			
			<AccessPointList ID="REPNAV_SCAT_RETAIL_VEND" Name="Supplier">
				<AccessPointItemRef REFID="REPAPI_RETAIL_BILLS_BY_DUEDATE"/>
				<AccessPointItemRef REFID="REPAPI_SALESTAX"/>
				<AccessPointItemRef REFID="REPAPI_RETAIL_VNDR_BY_PURCHASE_VOL"/>
				<AccessPointItemRef REFID="REPAPI_RETAIL_VNDR_RETURNS_SMRY"/>
				<AccessPointItemRef REFID="REPAPI_RETAIL_VNDR_RETURNS_DETAIL"/>
				<AccessPointItemRef REFID="REPAPI_RETAIL_OPENPURCHASEORDERS_BY_VENDOR"/>				
				<AccessPointItemRef REFID="REPAPI_GRAPHAPSUMMARY"/>
			</AccessPointList>
		
		</AccessPointList>	

		<!-- ________________________________Category_________________________ -->

		<AccessPointList ID="REPNAV_CAT_NONPROFIT" Visible="Features.RPT_NonprofitStandardReports='enabled'" Name="Nonprofit">
			<Description>Find reports that are particularly useful for nonprofit businesses.</Description>

			<AccessPointList ID="REPNAV_SCAT_NONPROFIT_DONORS" Name="Donors/Grants">
				<AccessPointItemRef REFID="REPAPI_NONPROFIT_BIGGEST_DONORS"/>
				<AccessPointItemRef REFID="REPAPI_NONPROFIT_BUDGET_VS_ACTUAL_BY_DONORS"/>
				<AccessPointItemRef REFID="REPAPI_NONPROFIT_DONORS"/>
				<AccessPointItemRef REFID="REPAPI_NONPROFIT_DONOR_CONTRIBUTION_SUMMARY"/>
			</AccessPointList>

			<AccessPointList ID="REPNAV_SCAT_NONPROFIT_PROGRAMS" Name="Programs/Projects">
				<AccessPointItemRef REFID="REPAPI_NONPROFIT_BUDGET_VS_ACTUAL_BY_PROGRAMS"/>
				<AccessPointItemRef REFID="REPAPI_NONPROFIT_PROGRAMS"/>
			</AccessPointList>

			<AccessPointList ID="REPNAV_SCAT_NONPROFIT_OTHER" Name="Other">
				<AccessPointItemRef REFID="REPAPI_NONPROFIT_FINANCIAL_INCOME"/>
				<AccessPointItemRef REFID="REPAPI_NONPROFIT_FINANCIAL_POSITION"/>
        <!-- ifndef INTL_AU -->
        <!-- <AccessPointItemRef REFID="REPAPI_NONPROFIT_FUNCTIONAL_EXPENSES"/> -->
        <!-- endif -->
			</AccessPointList>
		
		</AccessPointList>
	
	</AccessPointList> <!-- REPORT_NAVIGATOR -->
		
</AppDef>
