perl实例

#!/opt/perl/5.8.0/bin/perl
#ident "%W%"

$run_time = &timestamp();

#$asof = substr($run_time, 0, 8);
$asof = $ARGV[0];
$default_stale_cutoff = $ARGV[1];
$default_stale_cutoff = 30 if $default_stale_cutoff <= 0;


$light_yellow="#FFFF88";
$light_red="#FC8E8E";
$orange="#FFA500";

$emct_subord_map->{"SENIOR_UNSECURED"} = "sen";
$emct_subord_map->{"SENIOR_SECURED"} = "sensec";
$emct_subord_map->{"SUBORDINATE"} = "sub";

$ca_subord_map->{"SENIOR_UNSECURED"} = "sen";
$ca_subord_map->{"SENIOR_SECURED"} = "sensec";
$ca_subord_map->{"SUBORDINATE"} = "sub";

$tennor_map->{"3M"} = "3M";
$tennor_map->{"6M"} = "6M";
$tennor_map->{"1Y"} = "1Y";
$tennor_map->{"2Y"} = "2Y";
$tennor_map->{"3Y"} = "3Y";
$tennor_map->{"4Y"} = "4Y";
$tennor_map->{"5Y"} = "5Y";
$tennor_map->{"7Y"} = "7Y";
$tennor_map->{"10Y"} = "10Y";
$tennor_map->{"15Y"} = "15Y";
$tennor_map->{"20Y"} = "20Y";
$tennor_map->{"30Y"} = "30Y";


# load excluded list
$basedir = $ENV{"GCDR_BASEDIR"};
open(EX_FILE, "< $basedir/config/excluded.txt");
print "open file $basedir/config/excluded.txt\n";
while ($line = <EX_FILE>)
{
chomp($line);
# remove heading etc
if ($line =~ /^(-|\s|\|)*$|^\(.*rows affected\)$|^\(return status =.*\)$/)
{next;}
if ($line =~ /^\|exclude_type\s*\|ticker\s*\|reason\s*\|/)
{next;}
($dummy,
$excluded_type,
$ticker,
$reason) = split (/\s*\|\s*|\|/, $line);

$excluded_list->{$excluded_type}->{$ticker} = $reason;
}
close(EX_FILE);

open(MAP_FILE, "< subord_map_$asof.txt");
while ($line = <MAP_FILE>)
{
chomp($line);
# remove heading etc
if ($line =~ /^(-|\s|\|)*$|^\(.*rows affected\)$|^\(return status =.*\)$/)
{next;}
if ($line =~ /^\|code\s*\|name\s*\|/)
{next;}
($dummy,
$code,
$name) = split (/\s*\|\s*|\|/, $line);

$subord_map->{$code} = $name;
}
close(MAP_FILE);

open(MAP_FILE, "< curve_type_map_$asof.txt");
while ($line = <MAP_FILE>)
{
chomp($line);
# remove heading etc
if ($line =~ /^(-|\s|\|)*$|^\(.*rows affected\)$|^\(return status =.*\)$/)
{next;}
if ($line =~ /^\|type\s*\|name\s*\|/)
{next;}
($dummy,
$type,
$name) = split (/\s*\|\s*|\|/, $line);
$curve_type_map->{$type} = $name;
}
close(MAP_FILE);

open(MAP_FILE, "< desk_map_$asof.txt");
while ($line = <MAP_FILE>)
{
chomp($line);
# remove heading etc
if ($line =~ /^(-|\s|\|)*$|^\(.*rows affected\)$|^\(return status =.*\)$/)
{next;}
if ($line =~ /^\|owner_code\s*\|label\s*\|/)
{next;}
($dummy,
$desk,
$label) = split (/\s*\|\s*|\|/, $line);
$desk_map->{$desk} = $label;
}
close(MAP_FILE);

open(MAP_FILE, "< sector_map_$asof.txt");
while ($line = <MAP_FILE>)
{
chomp($line);
# remove heading etc
if ($line =~ /^(-|\s|\|)*$|^\(.*rows affected\)$|^\(return status =.*\)$/)
{next;}
if ($line =~ /^\|sector_id\s*\|owner_code\s*\|label\s*\|/)
{next;}
($dummy,
$sector_id, $desk, $label) = split (/\s*\|\s*|\|/, $line);
$sector_map->{$sector_id}->{desk} = $desk;
$sector_map->{$sector_id}->{label} = $label;
}
close(MAP_FILE);

open(USER_FILE, "< user_file_${asof}.txt");
while ($line = <USER_FILE>)
{
chomp($line);
# remove heading etc
if ($line =~ /^(-|\s|\|)*$|^\(.*rows affected\)$|^\(return status =.*\)$/)
{next;}
if ($line =~ /^username/)
{next;}
($dummy, $user_id, $name) = split (/\s*\|\s*|\|/, $line);

$username_map->{$user_id} = $name;
}
close(USER_FILE);

open(ISSUER_FILE, "< issuer_map_${asof}.txt");
while ($line = <ISSUER_FILE>)
{
chomp($line);
# remove heading etc
if ($line =~ /^(-|\s|\|)*$|^\(.*rows affected\)$|^\(return status =.*\)$/)
{next;}
if ($line =~ /^issuer_id/)
{next;}
($dummy, $issuer_id, $ticker, $name, $sector_id) = split (/\s*\|\s*|\|/, $line);

$issuer_sector_map->{$issuer_id} = $sector_id;
}
close(ISSUER_FILE);

open(SNAP_FILE, "< stale_snapshot_${asof}.txt");
while ($line = <SNAP_FILE>)
{
chomp($line);
# remove heading etc
if ($line =~ /^(-|\s|\|)*$|^\(.*rows affected\)$|^\(return status =.*\)$/)
{next;}
if ($line =~ /^curve_id/)
{next;}
($curve_id, $last_date) = split (/\s*\|\s*|\|/, $line);

$last_change_date->{$curve_id} = $last_date;
}
close(SNAP_FILE);

open(BLOTTER_FILE, "< blotter_file_${asof}.txt");
while ($line = <BLOTTER_FILE>)
{
chomp($line);
# remove heading etc
if ($line =~ /^(-|\s|\|)*$|^\(.*rows affected\)$|^\(return status =.*\)$/)
{next;}
if ($line =~ /^instrument_id/)
{next;}
($dummy, $curve_id, $owner_code) = split (/\s*\|\s*|\|/, $line);

$blotter_id_sector_map->{$curve_id} = $owner_code;
}
close(BLOTTER_FILE);

open(CURVE_FILE, "< GCDR.curves_${asof}_1830.revised") or print "Cannot open GCDR.curves_${asof}_1830.revised\n";
while ($line = <CURVE_FILE>)
{
chomp($line);
# remove heading etc
if ($line =~ /^issuerName\|issuerShortCode/)
{next;}
($issuerName, $issuerShortCode, $curveCurrency, $curveSubord, $docClause, $curveId, $curveSource, $curveRecovery, $countryName, $issuerId, $curveLastModTime,
$curveRollType, $curveMaturity, $countryIsoCode, $curveType, $curveStatus, $moodyIndustry, $moodyRating, $moodyWatch, $snpRating,
$snpWatch, $moodyOutlook, $snpOutlook, $isin, $cbCurveId, $sourceLabel, $curveExternalName,
$curvePath, $curveShortCode, $curveEnteredUser, $issuerLegalName) = split (/\s*\|\s*|\|/, $line);

if ($curveStatus ne "ok") {next;}

#AP
$gcdr_curves->{$issuerShortCode}->{$curveCurrency}->{$curveSubord}->{$docClause}->{$curveType}->{$curveSource} = $curveId;

if ($curveSource eq "pc") {
$pc_map_list->{$issuerShortCode}->{$curveCurrency}->{$curveSubord}->{$docClause}->{$curveType} = $curveId;

$issuer_map->{$curveId}->{ticker} = $issuerShortCode;
$issuer_map->{$curveId}->{subord} = $curveSubord;
$issuer_sector_id = $issuer_sector_map->{$issuerId};
$ticker_sector_map->{$issuerShortCode} = &get_sector_label($issuer_sector_id);
} elsif ($curveExternalName ne "NULL") {
$src_id_to_name->{$curveId} = $curveExternalName;
$src_name_to_ticker->{$curveSource}->{$curveExternalName} = $issuerShortCode;
$src_name_to_subord->{$curveSource}->{$curveExternalName} = $curveSubord;
}

if ($curveSource eq "blotter") {
$src_id_to_name->{$curveId} = $curveShortCode;
}
}
close(CURVE_FILE);

open(CURVE_FILE, "< GCDR.curves_${asof}_1830.revised");
while ($line = <CURVE_FILE>)
{
chomp($line);
# remove heading etc
if ($line =~ /^issuerName\|issuerShortCode/)
{next;}
($issuerName, $issuerShortCode, $curveCurrency, $curveSubord, $docClause, $curveId, $curveSource, $curveRecovery, $countryName, $issuerId, $curveLastModTime,
$curveRollType, $curveMaturity, $countryIsoCode, $curveType, $curveStatus, $moodyIndustry, $moodyRating, $moodyWatch, $snpRating,
$snpWatch, $moodyOutlook, $snpOutlook, $isin, $cbCurveId, $sourceLabel, $curveExternalName,
$curvePath, $curveShortCode, $curveEnteredUser, $issuerLegalName) = split (/\s*\|\s*|\|/, $line);

if ($curveStatus ne "ok") {next;}

if ($curveSource ne "pc" && $curveExternalName ne "NULL") {
$prc_curve_id = $pc_map_list->{$issuerShortCode}->{$curveCurrency}->{$curveSubord}->{$docClause}->{$curveType};
$src_name_to_pc_id->{$curveSource}->{$curveExternalName} = $prc_curve_id;
}
}
close(CURVE_FILE);

open(LEVEL_FILE, "< GCDR.levels_${asof}_1830.roll");
while ($line = <LEVEL_FILE>)
{
chomp($line);
# remove heading etc
if ($line =~ /^curve_id\|roll/)
{next;}
($curve_id, $roll, $type, $tag, $roll_date, $date, $maturity, $maturity_string, $bid, $ask, $entered_date, $entered_user) = split (/\s*\|\s*|\|/, $line);

if ($type eq "close" && $tag eq "") {
$last_close_date->{$curve_id} = $date;
$last_close_user->{$curve_id} = $entered_user;

#AP - load mid levels
$gcdr_levels->{$curve_id}->{$tennor_map->{$maturity_string}} = ($bid + $ask)/2;
#print "$curve_id|$tennor_map->{$maturity_string}|$gcdr_levels->{$curve_id}->{$tennor_map->{$maturity_string}}\n";
}
}
close(LEVEL_FILE);

open (PCFILE, "< pc_file_$asof.txt");
while ($line = <PCFILE>)
{
chomp($line);

# remove heading etc
if ($line =~ /curve_id\b|^(-|\s|\|)*$|^\(.*rows affected\)$|^\(return status =.*\)$/)
{next;}

($dummy,
$prc_curve_id,
$prc_source,
$prc_ref_id
) = split (/\s*\|\s*|\|/, $line);

$pc_source_map->{$prc_curve_id} = $prc_source;
$pc_ref_id_map->{$prc_curve_id} = $prc_ref_id;
}
close (PCFILE);

open(PT_FILE, "< curves.csv_$asof");
while (<PT_FILE>) {
chomp;
($creditRiskId,
$issuerId,
$curveId,
$issuerNameAndSubord,
$date,
$currency,
$frequency,
$daycount,
$calendar,
$rollingConvention,
$industry,
$recovery,
$accrue,
$numPoints,
@levels) = split /,/;

$recovery *= 100.0 if $recovery != 0;

# if (defined($recovery)) {
$pt_recovery_list->{$curveId}->{$recovery} = $curveId;
# }

$prc_ticker = $issuer_map->{$curveId}->{ticker};
$prc_subord = $issuer_map->{$curveId}->{subord};
$pt_rating_list->{$prc_ticker}->{$prc_subord}->{"//"} = $curveId;

for ($i = 0; $i < $numPoints; $i++) {
$t_str = $levels[2 * $i];
$l = $levels[2 * $i + 1];
if ($t_str =~ /(\d+)Y\b/) {
$t = $1 . ".000000";
$pt_level_list->{$curveId}->{$t} = $l;
} elsif ($t_str =~ /(\d+)M\b/) {
$t = sprintf("%8.6f", $1 / 12.0);
$pt_level_list->{$curveId}->{$t} = $l;
}
}
}
close(PT_FILE);

@storm_trade_files = `ls mkt_tmapp_NY_STORM.*$asof*`;
foreach $storm_trade_file (@storm_trade_files) {
$storm_db = "";
open(STORM_TRADE_FILE, "< $storm_trade_file");
while ($line = <STORM_TRADE_FILE>) {
if ($line =~ /^#/) {
if ($line =~ /\|DATABASE=(\w+)\|/) {
$storm_db = $1;
}
} else {
chomp($line);

($storm_trade_id,
$oasys_id,
$type,
$description,
$curve) = split (/\|/, $line);

$storm_active_list->{"$storm_db/$curve"}->{$type} += 1;
}
}
close(STORM_TRADE_FILE);
}


open(GK_FILE, "< gk_curve_$asof.txt");
while (<GK_FILE>) {
chomp;
@fields = split /\s*\|\s*|\|/;
if ($fields[4] =~ /^Z/ && $fields[25] =~ /Default Swap/ && defined($fields[22]) && $fields[20] ne "") {
$gk_curve = "$fields[7]/$fields[20]";
$gk_recovery = $fields[22];
$prc_curve_id = $src_name_to_pc_id->{"gk"}->{$gk_curve};
if (defined($prc_curve_id)) {
$gk_recovery_list->{$prc_curve_id}->{$gk_recovery} = $gk_curve;
} else {
# Unmapped GK curve
}
}
}
close(GK_FILE);

open (STORM_FILE, "< storm_curves_$asof.txt");
while ($line = <STORM_FILE>)
{
chomp($line);

# remove heading etc
if ($line =~ /source\b|^(-|\s|\|)*$|^\(.*rows affected\)$|^\(return status =.*\)$/)
{next;}
($dummy,
$storm_db,
$storm_curve,
$storm_recovery,
$storm_mdy,
$storm_snp) = split (/\s*\|\s*|\|/, $line);

$storm_recovery = "" if $storm_recovery eq "NULL";
# Rating
##$storm_mdy = "-" if $storm_mdy =~ /^N|^\s*$/;
##$storm_snp = "-" if $storm_snp =~ /^N|^\s*$/;
$storm_mdy = "-" if $storm_mdy =~ /^NotRa|^\s*$/;
$storm_snp = "-" if $storm_snp =~ /^NotRa|^\s*$/;
$prc_curve_id = $src_name_to_pc_id->{"storm"}->{$storm_curve};
$prc_ticker = $src_name_to_ticker->{"storm"}->{$storm_curve};
$prc_subord = $src_name_to_subord->{"storm"}->{$storm_curve};

if (defined($storm_active_list->{"$storm_db/$storm_curve"})) {
$storm_recovery_list->{$prc_curve_id}->{$storm_recovery} = "$storm_db/$storm_curve";
$storm_rating_list->{$prc_ticker}->{$prc_subord}->{"$storm_snp/$storm_mdy/"} = "$storm_db/$storm_curve";
}

$all_storm_recovery_list->{$storm_curve}->{$storm_db} = $storm_recovery;
$all_storm_db_list->{$storm_db} = 1;
}
close(STORM_FILE);

open (MARKIT_FILE, "< markit_file_$asof.txt");

while ($line = <MARKIT_FILE>)
{
chomp($line);

# remove heading etc
if ($line =~ /instrument_id\b|^(-|\s|\|)*$|^\(.*rows affected\)$|^\(return status =.*\)$/)
{next;}
($dummy,
$markit_curve,
$markit_recovery,
$prc_curve_id,
$markit_composite) = split (/\s*\|\s*|\|/, $line);

$markit_recovery = "" if $markit_recovery eq "NULL";
$markit_curve = "" if $markit_curve eq "NULL";

$markit_composite = "" if $markit_composite eq "NULL";
$markit_composite *= 100.0 if $markit_composite != 0;

$markit_recovery_list->{$prc_curve_id}->{$markit_recovery} = $markit_curve;
$markit_comp_list->{$prc_curve_id}->{$markit_recovery} = $markit_composite;
}
close(MARKIT_FILE);

@emct_trade_files = `ls EMCT.*.$asof`;

foreach $emct_file (@emct_trade_files) {
read_emct_file($emct_file);
}

$emct_recovery_list = &read_calypso_curve_file("EMCTCurveRecoveryRate_${asof}.txt", $emct_curve_list);

@calypso_trade_files = `ls solarfeed.*.$asof`;

foreach $calypso_file (@calypso_trade_files) {
read_calypso_file($calypso_file);
}

$ca_recovery_list = &read_calypso_curve_file("FlowCurveRecoveryRate_${asof}.txt", $ca_curve_list);

open (CFILE, "< GCDR.curves_${asof}_1830.revised");
open (UFILE, "> pc_usage.csv");
open (UMAP_FILE, "> calypso_umapped.txt");
open (EUMAP_FILE, "> emct_umapped.txt");
while ($line = <CFILE>)
{
chomp($line);
# remove heading etc
if ($line =~ /^issuerName\|issuerShortCode/)
{next;}
($issuerName, $issuerShortCode, $curveCurrency, $curveSubord, $docClause, $curveId, $curveSource, $curveRecovery, $countryName, $issuerId, $curveLastModTime,
$curveRollType, $curveMaturity, $countryIsoCode, $curveType, $curveStatus, $moodyIndustry, $moodyRating, $moodyWatch, $snpRating,
$snpWatch, $moodyOutlook, $snpOutlook, $isin, $cbCurveId, $sourceLabel, $curveExternalName,
$curvePath, $curveShortCode, $curveEnteredUser, $issuerLegalName) = split (/\s*\|\s*|\|/, $line);

if ($curveStatus ne "ok") {next;}

if ($curveSource eq "pc") {
#print "Processing PC ".$curveId;
process_recovery($curveId, $issuerId, $issuerName, $issuerShortCode, $curveCurrency, $curveSubord, $docClause, $curveType, $curveRecovery)
}
}

close (CFILE);
close (UFILE);

foreach $emct_curve (sort keys %$emct_cr01_list) {
print EUMAP_FILE "$emct_curve,$emct_cr01_list->{$emct_curve}\n";
}
close (EUMAP_FILE);

foreach $ca_curve (sort keys %$ca_cr01_list) {
print UMAP_FILE "$ca_curve,$ca_cr01_list->{$ca_curve}\n";
}
close (UMAP_FILE);

@all_storm_db = sort keys %$all_storm_db_list;

open(OFILE, "> recovery_recon.${asof}.xls");
open(OSFILE, "> storm_recon.${asof}.xls");

print OFILE <<EOF;
<html>
<head>
<title>Recovery Recon Report</title>
</head>
<body>
<p>Report Date: $asof</p>
EOF

print OSFILE <<EOF;
<html>
<head>
<title>Storm Recon Report</title>
</head>
<body>
<p>Report Date: $asof</p>
<table border="1" cellpadding="0" cellspacing="0">
<tr>
<td bgcolor="$light_yellow"><b>Action</b></td>
<td bgcolor="$light_yellow"><b>Owner</b></td>
<td bgcolor="$light_yellow"><b>Marx Ticker</b></td>
<td bgcolor="$light_yellow"><b>Marx Issuer Name</b></td>
<td bgcolor="$light_yellow"><b>CCY</b></td>
<td bgcolor="$light_yellow"><b>Subord</b></td>
<td bgcolor="$light_yellow"><b>Doc Clause</b></td>
<td bgcolor="$light_yellow"><b>Type</b></td>
<td bgcolor="$light_yellow"><b>Pricing Source</b></td>
<td bgcolor="$light_yellow"><b>Pricing Curve ID</b></td>
<td bgcolor="$light_yellow"><b>Marx Recovery</b></td>
<td bgcolor="$light_yellow"><b>Storm Curve</b></td>
EOF

foreach $storm_db (@all_storm_db) {
print OSFILE <<EOF;
<td bgcolor="$light_yellow"><b>$storm_db</b></td>
EOF
}

print OSFILE " </tr>\n";

open(SUM_FILE, "> summary_$asof.txt");

print_recovery_report("Recovery Rate Reconciliation Report", \@recovery_recon_report, 0);

print_mismatch_summary("Recovery Rate Reconciliation Report");

print_recovery_report("Zero Recovery in Marx", \@zero_report, 1);

print_recovery_report("Senior Unsecured Recovery not Valid in Marx", \@senior_not_40_report, 1);

print_recovery_report("Subordinated Recovery not Valid in Marx", \@sub_not_25_report, 1);

print_excluded_report(\@recovery_excluded_report, "recovery");

close(SUM_FILE);

print OFILE <<EOF;
</body>
</html>
EOF

print OSFILE <<EOF;
</table>
</body>
</html>
EOF

close (OFILE);
close (OSFILE);

open(SUM_FILE, "> stale_summary_$asof.txt");
print_stale_report(\@stale_report);

print_excluded_report(\@stale_excluded_report, "stale");
close(SUM_FILE);

print_prod_cntrl_report(\@stale_report_prod_ctrl);

open (RFILE, "< GCDR.issuer_ratings.data.$asof");
while ($line = <RFILE>) {
chomp($line);
if ($line =~ /^issuer_id\|ticker/)
{next;}

($issuer_id, $ticker, $name, $equity_ticker, $red, $country, $region, $industry, $sub, $subord, $mdy_rating, $snp_rating, $rni_rating, $fch_rating,
$mdy_watch, $snp_watch, $rni_watch, $fch_watch, $issuer_type) = split (/\s*\|\s*|\|/, $line);

process_rating($ticker, $name, $equity_ticker, $red, $sub, $subord, $snp_rating, $mdy_rating, $fch_rating);
}
close(RFILE);

open(SUM_FILE, "> rating_summary_$asof.txt");

open(SFILE, "> rating_recon.${asof}.xls");
print SFILE <<EOF;
<html>
<head>
<title>Issuer Rating Report</title>
</head>
<body>
<p>Report Date: $asof</p>
EOF
###print_rating_report("Issuer Rating Recon Report", \@rating_report);
print_rating_report("Missing rating everywhere", \@blank_rating_report2);
print_rating_report("Missing rating in Marx but present in another", \@blank_rating_report1);
print_rating_report("Rating Mismatch", \@rating_report);
print SFILE <<EOF;
</body>
</html>
EOF
close (SFILE);
print_rating_excluded_report(\@rating_excluded_report, "rating");
close(SUM_FILE);

###########################################################################

sub read_emct_file() {
my($fname) = @_;

open(EMCT_FILE, "< $fname") or return;

while (<EMCT_FILE>) {
@fields = split /\|/;
if ($fields[0] !~ /^\*/) {
$ops_file = $fields[4];
$firm_acct = $fields[10];
$trade_type = $fields[11];
$ticker = $fields[17];
$subord = $fields[18];
$snp= $fields[19];
$mdy = $fields[20];
$fch= $fields[21];
$term_date = $fields[23];
$emct_curve = $fields[42];
$emct_recovery = $fields[43];
$ccy = $fields[45];
$cr01 = $fields[76];
$dv01 = $fields[77];
$rr01 = $fields[80];

if ($emct_curve ne "") {
$emct_cr01_list->{"$emct_curve,$firm_acct"} += $cr01;
$emct_rr01_list->{"$emct_curve,$firm_acct"} += $rr01;
} elsif ($cr01 != 0.0) {
# print "No Curve: $ticker, $cr01\n";
}

if ($trade_type eq "CreditDefaultSwap" && $term_date eq "" &&
$emct_curve =~ /^(\S+)-pc-(.+)$/) {
@tail = split /-/, $emct_curve;
$prc_curve_id = $tail[-1];
if ($prc_curve_id ne "") {
#$curve_recovery = $emct_curve_recovery_list->{$prc_curve_id};
#if (!defined($curve_recovery)) {
# $curve_recovery = $emct_recovery;
#}
#$emct_recovery_list->{$prc_curve_id}->{$curve_recovery} = $emct_curve;
$emct_curve_list->{$prc_curve_id} = $emct_curve;

# Rating
#$mdy = "-" if $mdy =~ /^N|^W|^\s*$/;
#$snp = "-" if $snp =~ /^N|^W|^\s*$/;
#$fch = "-" if $fch =~ /^N|^W|^\s*$/;
$emct_rating_list->{$ticker}->{$emct_subord_map->{$subord}}->{"$snp/$mdy/$fch"} = $emct_curve;

}
}
}
}
close(EMCT_FILE);
}

sub read_calypso_file() {
my($fname) = @_;

open(CA_FILE, "< $fname") or return;

while (<CA_FILE>) {
@fields = split /\|/;
if ($fields[0] !~ /^\*/) {
$ops_file = $fields[4];
$firm_acct = $fields[10];
$trade_type = $fields[11];
$ticker = $fields[17];
$subord = $fields[18];
$snp= $fields[19];
$mdy = $fields[20];
$fch= $fields[21];
$term_date = $fields[23];
$ca_curve = $fields[42];
$ca_recovery = $fields[43];
$ccy = $fields[45];
$cr01 = $fields[76];
$dv01 = $fields[77];
$rr01 = $fields[80];

if ($ca_curve ne "") {
$ca_cr01_list->{"$ca_curve,$firm_acct"} += $cr01;
$ca_rr01_list->{"$ca_curve,$firm_acct"} += $rr01;
} elsif ($cr01 != 0.0) {
# print "No Curve: $ticker, $cr01\n";
}

if ($trade_type eq "CreditDefaultSwap" && $term_date eq "" &&
$ca_curve =~ /^(\S+)-pc-(.+)$/) {
# AMCOR-pc-USD-SEN-MR-19965
# 03072STM7-pc-USD-SEN-mbs-64213
# 437084CE4-pc-USD-SEN-mbs-NA-71570
@tail = split /-/, $ca_curve;
$prc_curve_id = $tail[-1];
if ($prc_curve_id ne "") {
#$curve_recovery = $ca_curve_recovery_list->{$prc_curve_id};
#if (!defined($curve_recovery)) {
# $curve_recovery = $ca_recovery;
#}
#$ca_recovery_list->{$prc_curve_id}->{$curve_recovery} = $ca_curve;
$ca_curve_list->{$prc_curve_id} = $ca_curve;

# Rating
#$mdy = "-" if $mdy =~ /^N|^W|^\s*$/;
#$snp = "-" if $snp =~ /^N|^W|^\s*$/;
#$fch = "-" if $fch =~ /^N|^W|^\s*$/;
$ca_rating_list->{$ticker}->{$ca_subord_map->{$subord}}->{"$snp/$mdy/$fch"} = $ca_curve;

}
}
}
}
close(CA_FILE);
}


sub read_calypso_curve_file() {
my($fname, $curve_list) = @_;
my($curve_recovery_list) = {};

open(CA_FILE, "< $fname") or return;

while ($line = <CA_FILE>) {
chomp($line);
if ($line =~ /^ticker_name\|/)
{next;}
my ($ca_curve, $ca_recovery) = split(/\|/, $line);
if ($ca_curve =~ /^(\S+)-pc-(.+)$/) {
# AMCOR-pc-USD-SEN-MR-19965
# 03072STM7-pc-USD-SEN-mbs-64213
# 437084CE4-pc-USD-SEN-mbs-NA-71570
@tail = split /-/, $ca_curve;
$prc_curve_id = $tail[-1];
if ($prc_curve_id ne "") {
$ca_curve = $curve_list->{$prc_curve_id};
if (defined($ca_curve)) {
$curve_recovery = $ca_recovery*100.0;
$curve_recovery_list->{$prc_curve_id}->{$curve_recovery} = $ca_curve;
}
}
}
}
close(CA_FILE);
return $curve_recovery_list;
}


sub print_recovery_report() {
my($rpt_title, $rpt, $print_sector_summary) = @_;

$num_curves = scalar @$rpt;

print OFILE <<EOF;
<p><b>$rpt_title</b> ($num_curves curves)</p>
<table border="1" cellpadding="0" cellspacing="0">
<tr>
<td bgcolor="$light_yellow"><b>Action</b></td>
<td bgcolor="$light_yellow"><b>Owner</b></td>
<td bgcolor="$light_yellow"><b>Marx Ticker</b></td>
<td bgcolor="$light_yellow"><b>Marx Issuer Name</b></td>
<td bgcolor="$light_yellow"><b>CCY</b></td>
<td bgcolor="$light_yellow"><b>Subord</b></td>
<td bgcolor="$light_yellow"><b>Doc Clause</b></td>
<td bgcolor="$light_yellow"><b>Type</b></td>
<td bgcolor="$light_yellow"><b>Pricing Source</b></td>
<td bgcolor="$light_yellow"><b>Pricing Curve ID</b></td>
<td bgcolor="$light_yellow"><b>Last Close Date</b></td>
<td bgcolor="$light_yellow"><b>Username</b></td>
<td bgcolor="$light_yellow"><b>Marx Recovery</b></td>
<td bgcolor="$light_yellow"><b>Mark-It Name</b></td>
<td bgcolor="$light_yellow"><b>Mark-It Composite</b></td>
<td bgcolor="$light_yellow"><b>Mark-It Recovery</b></td>
<td bgcolor="$light_yellow"><b>EMCT Name</b></td>
<td bgcolor="$light_yellow"><b>EMCT Recovery</b></td>
<td bgcolor="$light_yellow"><b>Calypso Name</b></td>
<td bgcolor="$light_yellow"><b>Calypso Recovery</b></td>
<td bgcolor="$light_yellow"><b>PT Recovery</b></td>
<td bgcolor="$light_yellow"><b>Storm Name</b></td>
<td bgcolor="$light_yellow"><b>Storm Recovery</b></td>
<td bgcolor="$light_yellow"><b>GK Name</b></td>
<td bgcolor="$light_yellow"><b>GK Recovery</b></td>
</tr>
EOF

my($sector_summary) = {};

foreach $rec (sort {$a->{prc_sector} cmp $b->{prc_sector} || $a->{prc_source} cmp $b->{prc_source} || $a->{prc_ticker} cmp $b->{prc_ticker} || $a->{prc_currency} cmp $b->{prc_currency} || $a->{prc_subord} cmp $b->{prc_subord} || $a->{prc_doc_id} cmp $b->{prc_doc_id}} @$rpt) {

$desk = &get_summary_desk($rec->{prc_sector});
$sector_summary->{$desk} += 1;

print OFILE <<EOF;
<tr>
<td>$rec->{prc_action}</td>
<td>$rec->{prc_sector}</td>
<td>$rec->{prc_ticker}</td>
<td>$rec->{prc_iname}</td>
<td>$rec->{prc_currency}</td>
<td>$rec->{prc_subord}</td>
<td>$rec->{prc_doc_id}</td>
<td>$rec->{prc_type}</td>
<td>$rec->{prc_source}</td>
<td>$rec->{prc_curve_id}</td>
<td>$rec->{prc_last_date}</td>
<td>$rec->{prc_last_user}</td>
<td $rec->{prc_color}>$rec->{prc_recovery}</td>
<td>$rec->{markit_id}</td>
<td>$rec->{markit_comp}</td>
<td $rec->{markit_color}>$rec->{markit_recovery}</td>
<td>$rec->{emct_id}</td>
<td $rec->{emct_color}>$rec->{emct_recovery}</td>
<td>$rec->{ca_id}</td>
<td $rec->{ca_color}>$rec->{ca_recovery}</td>
<td $rec->{pt_color}>$rec->{pt_recovery}</td>
<td>$rec->{storm_id}</td>
<td $rec->{storm_color}>$rec->{storm_recovery}</td>
<td>$rec->{gk_id}</td>
<td $rec->{gk_color}>$rec->{gk_recovery}</td>
</tr>
EOF
if ($rec->{storm_id} ne "" || $rec->{prc_source} eq "storm") {
if ($rec->{storm_id} eq "" && $rec->{prc_source} eq "storm") {
$storm_curve = $src_id_to_name->{$rec->{prc_ref_id}}
} else {
$storm_curve = $rec->{storm_id};
$storm_curve =~ s/^.*\///;
}

print OSFILE <<EOF;
<tr>
<td>$rec->{prc_action}</td>
<td>$rec->{prc_sector}</td>
<td>$rec->{prc_ticker}</td>
<td>$rec->{prc_iname}</td>
<td>$rec->{prc_currency}</td>
<td>$rec->{prc_subord}</td>
<td>$rec->{prc_doc_id}</td>
<td>$rec->{prc_type}</td>
<td>$rec->{prc_source}</td>
<td>$rec->{prc_curve_id}</td>
<td $rec->{prc_color}>$rec->{prc_recovery}</td>
<td>$storm_curve</td>
EOF

foreach $storm_db (@all_storm_db) {
$storm_recovery = $all_storm_recovery_list->{$storm_curve}->{$storm_db};
$storm_color = (defined($storm_recovery) && $storm_recovery != $rec->{prc_recovery})?"bgcolor=\"$light_red\"":"";
print OSFILE <<EOF;
<td $storm_color>$storm_recovery</td>
EOF
}

print OSFILE " </tr>\n";
}
}
print OFILE <<EOF;
</table>
EOF

if ($print_sector_summary) {
print SUM_FILE "$rpt_title\n\n";
if (keys %$sector_summary > 0) {
foreach $desk (sort keys %$sector_summary) {
$n_mismatch = $sector_summary->{$desk};
print SUM_FILE sprintf "\t%35s%6d\n", ($desk,$n_mismatch);
}
} else {
print SUM_FILE sprintf "\t%35s\n", ("None");
}
print SUM_FILE "\n";
}
}

sub process_recovery() {
my($prc_curve_id, $prc_issuer_id, $prc_iname, $prc_ticker, $prc_currency, $prc_subord_id, $prc_doc_id, $prc_type_id, $prc_recovery) = @_;
#print join('|', "Processing ", $prc_curve_id, $prc_issuer_id, $prc_iname, $prc_ticker, $prc_currency, $prc_subord_id, $prc_doc_id, $prc_type_id, $prc_recovery);
$prc_source = $pc_source_map->{$prc_curve_id};
$prc_ref_id = $pc_ref_id_map->{$prc_curve_id};

#AP
$prc_owner_id = $blotter_id_sector_map->{$prc_ref_id};
$prc_sector = $desk_map->{$prc_owner_id};

$prc_subord = $subord_map->{$prc_subord_id};
$prc_type = $curve_type_map->{$prc_type_id};

$prc_recovery = 0.0 if $prc_recovery eq "NULL";

# $prc_last_date = $last_close_date->{$prc_curve_id};
$summary_desk = &get_summary_desk($prc_sector);
$prc_last_date = $last_close_date->{$prc_curve_id};
$prc_last_date_prod_ctrl = $prc_last_date;
$prc_last_change_date = $last_change_date->{$prc_curve_id};
$prc_use_level_change = "";
$prc_use_level_change_prod_ctrl = "";

$consecutive_days_closed_same = "";

if (defined($excluded_list->{"level_change"}->{$summary_desk}) && defined($prc_last_change_date) && $prc_last_change_date < $prc_last_date) {
$prc_last_date = $prc_last_change_date;
$prc_use_level_change = "Yes";
}


if (defined($excluded_list->{"level_change_prod_ctrl"}->{$summary_desk}) && defined($prc_last_change_date) && $prc_last_change_date < $prc_last_date_prod_ctrl) {
$consecutive_days_closed_same = &diff_dates($asof, $prc_last_change_date);
$prc_last_date_prod_ctrl = $prc_last_change_date;
$prc_use_level_change_prod_ctrl = "Yes";
}

$prc_last_date = "" if $prc_last_date eq "NULL";
$prc_last_date_prod_ctrl = "" if $prc_last_date_prod_ctrl eq "NULL";

$prc_last_user = $last_close_user->{$prc_curve_id};
if (defined($username_map->{$prc_last_user})) {
$prc_last_user = $username_map->{$prc_last_user};
}

my($markit_recovery, $markit_id, $markit_comp, $markit_mismatch, $markit_color);
my($pt_recovery, $pt_id, $pt_mismatch, $pt_color);
my($gk_recovery, $gk_id, $gk_mismatch, $gk_color);
my($emct_recovery, $emct_id, $emct_mismatch, $emct_color);
my($ca_recovery, $ca_id, $ca_mismatch, $ca_color);
my($storm_recovery, $storm_id, $storm_mismatch, $storm_color);

$nn = 0;

@markit_rates = sort keys %{$markit_recovery_list->{$prc_curve_id}};
$n_markit = @markit_rates;
# $nn = $n_markit if $nn < $n_markit;

@pt_rates = sort keys %{$pt_recovery_list->{$prc_curve_id}};
$n_pt = @pt_rates;
$nn = $n_pt if $nn < $n_pt;

@gk_rates = sort keys %{$gk_recovery_list->{$prc_curve_id}};
$n_gk = @gk_rates;
$nn = $n_gk if $nn < $n_gk;

@emct_rates = sort keys %{$emct_recovery_list->{$prc_curve_id}};
$n_emct = @emct_rates;
if ($n_emct > 1) {
my($ok) = 0;

foreach $emct_rate (@emct_rates) {
if ($emct_rate == $prc_recovery) {
$ok = 1;
break;
}
}
if ($ok) {
@emct_rates = ($prc_recovery);
$n_emct = @emct_rates;
}
}
$nn = $n_emct if $nn < $n_emct;

if ($emct_curve_list->{$prc_curve_id} && $n_emct == 0) {
$emct_subord = uc $prc_subord_id;
if ($prc_type_id eq "cds") {
print EUMAP_FILE "$prc_ticker-pc-$prc_currency-$emct_subord-$prc_curve_id\t$emct_curve_list->{$prc_curve_id}\n";
} else {
print EUMAP_FILE "$prc_ticker-pc-$prc_currency-$emct_subord-$prc_type_id-$prc_curve_id\t$emct_curve_list->{$prc_curve_id}\n";
}
}

@ca_rates = sort keys %{$ca_recovery_list->{$prc_curve_id}};
$n_ca = @ca_rates;
if ($n_ca > 1) {
my($ok) = 0;

foreach $ca_rate (@ca_rates) {
if ($ca_rate == $prc_recovery) {
$ok = 1;
break;
}
}
if ($ok) {
@ca_rates = ($prc_recovery);
$n_ca = @ca_rates;
}
}
$nn = $n_ca if $nn < $n_ca;

if ($ca_curve_list->{$prc_curve_id} && $n_ca == 0) {
$ca_subord = uc $prc_subord_id;
if ($prc_type_id eq "cds") {
print UMAP_FILE "$prc_ticker-pc-$prc_currency-$ca_subord-$prc_curve_id\t$ca_curve_list->{$prc_curve_id}\n";
} else {
print UMAP_FILE "$prc_ticker-pc-$prc_currency-$ca_subord-$prc_type_id-$prc_curve_id\t$ca_curve_list->{$prc_curve_id}\n";
}
}

@storm_rates = sort keys %{$storm_recovery_list->{$prc_curve_id}};
$n_storm = @storm_rates;
$nn = $n_storm if $nn < $n_storm;

$prc_senior_not_40 = 0;
$prc_sub_not_25 = 0;
$action = "";

$standard_recovery = &get_standard_recovery($prc_sector, $prc_subord, $prc_ticker, $prc_iname, "HI");
$standard_recovery_lo = &get_standard_recovery($prc_sector, $prc_subord, $prc_ticker, $prc_iname, "LO");

$prc_is_zero = (! &allow_zero_recovery($prc_sector) && $prc_recovery == 0 && $standard_recovery != 0);

if ($prc_is_zero) {
$action = &get_action($prc_source, $prc_sector, $standard_recovery, $standard_recovery_lo);
}

if ($prc_source eq "gk") {
# should not use GK
if ($prc_subord =~ /^Senior Unsecured/) {
$prc_senior_not_40 = 1;
} else {
$prc_sub_not_25 = 1;
}
$action = &get_action($prc_source, "", $standard_recovery, $standard_recovery_lo);
}


$prc_mismatch = ($prc_is_zero || $prc_senior_not_40 || $prc_sub_not_25);
$prc_color = $prc_mismatch?"bgcolor=\"$light_red\"":"";

for ($i = 0; $i < $nn; $i++) {

if ($i < $n_markit) {
$markit_recovery = $markit_rates[$i];
$markit_id = $markit_recovery_list->{$prc_curve_id}->{$markit_recovery};
$markit_comp = $markit_comp_list->{$prc_curve_id}->{$markit_recovery};

$markit_mismatch = $markit_recovery ne "" && abs($prc_recovery - $markit_recovery) >= 1.0;
$markit_color = $markit_mismatch?"bgcolor=\"$light_red\"":"";
}

if ($i < $n_pt) {
$pt_recovery = $pt_rates[$i];
$pt_id = $pt_recovery_list->{$prc_curve_id}->{$pt_recovery};
$pt_mismatch = defined($pt_recovery) && (abs($prc_recovery - $pt_recovery) >= 1.0);
$pt_color = $pt_mismatch?"bgcolor=\"$light_red\"":"";
}

if ($i < $n_gk) {
$gk_recovery = $gk_rates[$i];
$gk_id = $gk_recovery_list->{$prc_curve_id}->{$gk_recovery};
$gk_mismatch = defined($gk_recovery) && (abs($prc_recovery - $gk_recovery) >= 1.0);
$gk_color = $gk_mismatch?"bgcolor=\"$light_red\"":"";
}

if ($i < $n_emct) {
$emct_recovery = $emct_rates[$i];
$emct_id = $emct_recovery_list->{$prc_curve_id}->{$emct_recovery};
$emct_mismatch = defined($emct_recovery) && (abs($prc_recovery - $emct_recovery) >= 1.0);
$emct_color = $emct_mismatch?"bgcolor=\"$light_red\"":"";
}

if ($i < $n_ca) {
$ca_recovery = $ca_rates[$i];
$ca_id = $ca_recovery_list->{$prc_curve_id}->{$ca_recovery};
$ca_mismatch = defined($ca_recovery) && (abs($prc_recovery - $ca_recovery) >= 1.0);
$ca_color = $ca_mismatch?"bgcolor=\"$light_red\"":"";
}

if ($i < $n_storm) {
$storm_recovery = $storm_rates[$i];
$storm_id = $storm_recovery_list->{$prc_curve_id}->{$storm_recovery};
$storm_mismatch = defined($storm_recovery) && (abs($prc_recovery - $storm_recovery) >= 1.0);
$storm_color = $storm_mismatch?"bgcolor=\"$light_red\"":"";
}

if ($i == 0) {
print UFILE join(',', $prc_curve_id, $prc_ticker,
$prc_currency, $prc_subord, $prc_type, $prc_recovery,
$prc_source, "\"$prc_sector\"", $prc_last_date, $emct_id, $ca_id, $pt_id, $storm_id, $gk_id, "\n");
}

#AP
#$markit_level = $gcdr_levels->{$markit_id} #will only work if we add the markit curve_id in the query in runReconRpt.ksh, line 93

$markit_curve_id = $gcdr_curves->{$prc_ticker}->{$prc_currency}->{$prc_subord_id}->{$prc_doc_id}->{$prc_type_id}->{"markit"};
# print join('|', "PC Details", $prc_curve_id, $prc_source, $prc_ref_id);
# print join('|', "Found Markit Curve", $markit_curve_id, $prc_ticker, $prc_currency, $prc_subord_id, $prc_doc_id, $prc_type_id);

#for all in tennor_map
$markit_level_3M = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"3M"}} : "";
$markit_level_6M = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"6M"}} : "";
$markit_level_1Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"1Y"}} : "";
$markit_level_2Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"2Y"}} : "";
$markit_level_3Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"3Y"}} : "";
$markit_level_4Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"4Y"}} : "";
$markit_level_5Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"5Y"}} : "";
$markit_level_7Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"7Y"}} : "";
$markit_level_10Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"10Y"}} : "";
$markit_level_15Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"15Y"}} : "";
$markit_level_20Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"20Y"}} : "";
$markit_level_30Y = $markit_curve_id ne "" ? $gcdr_levels->{$markit_curve_id}->{$tennor_map->{"30Y"}} : "";

$prc_level_3M= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"3M"}};
$prc_level_6M= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"6M"}};
$prc_level_1Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"1Y"}};
$prc_level_2Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"2Y"}};
$prc_level_3Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"3Y"}};
$prc_level_4Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"4Y"}};
$prc_level_5Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"5Y"}};
$prc_level_7Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"7Y"}};
$prc_level_10Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"10Y"}};
$prc_level_15Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"15Y"}};
$prc_level_20Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"20Y"}};
$prc_level_30Y= $gcdr_levels->{$prc_curve_id}->{$tennor_map->{"30Y"}};

# print "$prc_curve_id|$prc_ticker|$prc_currency|$prc_subord_id|$prc_type_id|$prc_level_5Y|$markit_curve_id|$markit_level_5Y\n";
# print "$markit_curve_id|$tennor_map->{\"5Y\"}|$gcdr_levels->{$markit_curve_id}->{$tennor_map->{\"5Y\"}}\n";
# print "$prc_curve_id|$tennor_map->{\"5Y\"}|$gcdr_levels->{$prc_curve_id}->{$tennor_map->{\"5Y\"}}\n";

my($rec) = {};
$rec->{prc_action} = $action;
$rec->{prc_sector} = $prc_sector;
$rec->{prc_ticker} = $prc_ticker;
$rec->{prc_iname} = $prc_iname;
$rec->{prc_currency} = $prc_currency;
$rec->{prc_subord} = $prc_subord;
$rec->{prc_doc_id} = $prc_doc_id;
$rec->{prc_type} = $prc_type;
$rec->{prc_source} = $prc_source;
$rec->{prc_curve_id} = $prc_curve_id;
$rec->{prc_ref_id} = $prc_ref_id;
$rec->{prc_color} = $prc_color;
$rec->{prc_recovery} = $prc_recovery;
$rec->{prc_last_date} = $prc_last_date;
$rec->{prc_last_date_prod_ctrl} = $prc_last_date_prod_ctrl;
$rec->{consecutive_days_closed_same} = $consecutive_days_closed_same;
$rec->{prc_use_level_change} = $prc_use_level_change;
$rec->{prc_use_level_change_prod_ctrl} = $prc_use_level_change_prod_ctrl;
$rec->{prc_last_user} = $prc_last_user;
$rec->{markit_id} = $markit_id;
$rec->{markit_curve_id} = $markit_curve_id;
$rec->{markit_comp} = $markit_comp;

#AP
$rec->{prc_level_3M} = $prc_level_3M;
$rec->{prc_level_6M} = $prc_level_6M;
$rec->{prc_level_1Y} = $prc_level_1Y;
$rec->{prc_level_2Y} = $prc_level_2Y;
$rec->{prc_level_3Y} = $prc_level_3Y;
$rec->{prc_level_4Y} = $prc_level_4Y;
$rec->{prc_level_5Y} = $prc_level_5Y;
$rec->{prc_level_7Y} = $prc_level_7Y;
$rec->{prc_level_10Y} = $prc_level_10Y;
$rec->{prc_level_15Y} = $prc_level_15Y;
$rec->{prc_level_20Y} = $prc_level_20Y;
$rec->{prc_level_30Y} = $prc_level_30Y;

$rec->{markit_level_3M} = $markit_level_3M;
$rec->{markit_level_6M} = $markit_level_6M;
$rec->{markit_level_1Y} = $markit_level_1Y;
$rec->{markit_level_2Y} = $markit_level_2Y;
$rec->{markit_level_3Y} = $markit_level_3Y;
$rec->{markit_level_4Y} = $markit_level_4Y;
$rec->{markit_level_5Y} = $markit_level_5Y;
$rec->{markit_level_7Y} = $markit_level_7Y;
$rec->{markit_level_10Y} = $markit_level_10Y;
$rec->{markit_level_15Y} = $markit_level_15Y;
$rec->{markit_level_20Y} = $markit_level_20Y;
$rec->{markit_level_30Y} = $markit_level_30Y;

$rec->{diff_level_3M} = $prc_level_3M-$markit_level_3M;
$rec->{diff_level_6M} = $prc_level_6M-$markit_level_6M;
$rec->{diff_level_1Y} = $prc_level_1Y-$markit_level_1Y;
$rec->{diff_level_2Y} = $prc_level_2Y-$markit_level_2Y;
$rec->{diff_level_3Y} = $prc_level_3Y-$markit_level_3Y;
$rec->{diff_level_4Y} = $prc_level_4Y-$markit_level_4Y;
$rec->{diff_level_5Y} = $prc_level_5Y-$markit_level_5Y;
$rec->{diff_level_7Y} = $prc_level_7Y-$markit_level_7Y;
$rec->{diff_level_10Y} = $prc_level_10Y-$markit_level_10Y;
$rec->{diff_level_15Y} = $prc_level_15Y-$markit_level_15Y;
$rec->{diff_level_20Y} = $prc_level_20Y-$markit_level_20Y;
$rec->{diff_level_30Y} = $prc_level_30Y-$markit_level_30Y;

$rec->{markit_color} = $markit_color;
$rec->{markit_recovery} = $markit_recovery;
$rec->{pt_id} = $pt_id;
$rec->{pt_color} = $pt_color;
$rec->{pt_recovery} = $pt_recovery;
$rec->{gk_id} = $gk_id;
$rec->{gk_color} = $gk_color;
$rec->{gk_recovery} = $gk_recovery;
$rec->{emct_id} = $emct_id;
$rec->{emct_color} = $emct_color;
$rec->{emct_recovery} = $emct_recovery;
$rec->{ca_id} = $ca_id;
$rec->{ca_color} = $ca_color;
$rec->{ca_recovery} = $ca_recovery;
$rec->{storm_id} = $storm_id;
$rec->{storm_color} = $storm_color;
$rec->{storm_recovery} = $storm_recovery;

$rec->{workdays_stale} = 1;

$stale_excluded = &excluded_stale($rec);
$no_standard = &no_standard($rec);

if ($no_standard) {
$rec->{excluded} = $no_standard;
push(@recovery_excluded_report, $rec);
} elsif ($prc_is_zero || $prc_senior_not_40 || $prc_sub_not_25) {
if ($prc_is_zero) {
push(@zero_report, $rec);
} elsif ($prc_senior_not_40) {
push(@senior_not_40_report, $rec);
} elsif ($prc_sub_not_25) {
push(@sub_not_25_report, $rec);
}
} elsif ($pt_mismatch || $gk_mismatch || $emct_mismatch || $ca_mismatch || $storm_mismatch) {
$rec->{prc_action} = get_mismatch_action($prc_source, $prc_sector, $pt_mismatch, $gk_mismatch, $emct_mismatch, $ca_mismatch, $storm_mismatch);
push(@recovery_recon_report, $rec);
add_mismatch_summary($pt_mismatch, $gk_mismatch, $emct_mismatch, $ca_mismatch, $storm_mismatch, $storm_id);
}

#
$stale_cutoff = &stale_threshhold($rec);
if (! $stale_cutoff) {
$stale_cutoff = $default_stale_cutoff;
}
# print "Stale Cutoff used for $prc_ticker: $stale_cutoff\n";

if (($n_emct > 0 || $n_ca > 0 || $n_pt > 0 || $n_gk > 0) && ($prc_last_date eq "" || &diff_dates($asof, $prc_last_date) > $stale_cutoff) || $consecutive_days_closed_same ne "" ) {
if ($i == 0) {
if ($stale_excluded) {
$rec->{excluded} = $stale_excluded;
push(@stale_excluded_report, $rec);
} else {
$flag = 0; #prevent duplicates from being added to product control report
if ($prc_last_date eq "" || (&diff_dates($asof, $prc_last_date) > $stale_cutoff) ) {
push(@stale_report, $rec);
push(@stale_report_prod_ctrl, $rec);
$flag = 1;
}
if ($consecutive_days_closed_same ne "") {
if ($flag == 0) {
push(@stale_report_prod_ctrl, $rec);
}
}
}
}
}
}
}

sub is_dummy_curve {
my($rec) = @_;

my($excluded) = $excluded_list->{"dummy"}->{$rec->{prc_ticker}};
return $excluded if $excluded;

# Mortgages
return "" if ($rec->{prc_ticker} eq "ABXHEAAA06");
return "" if ($rec->{prc_ticker} eq "ABXHEAA06");
return "" if ($rec->{prc_ticker} eq "ABXHEA06");
return "" if ($rec->{prc_ticker} eq "ABXHEBBB06");
return "" if ($rec->{prc_ticker} eq "ABXHEBBBM6");
return "Mortgage: Dummy Curve" if ($rec->{prc_sector} =~ /Mortgage/);

return "";
}


sub no_standard() {
my($rec) = @_;

my($excluded) = $excluded_list->{"recovery"}->{$rec->{prc_ticker}};
return $excluded if $excluded;


# Paul Lim, Dan McCarthy
return "NA SN: Special Subordinated" if ($rec->{prc_ticker} eq "TSO" && $rec->{prc_subord} eq "Subordinated");

return "NSSB: non-standard rate" if ($rec->{prc_ticker} =~ /^ITRXAB5/ &&
$rec->{prc_sector} =~ /^NSSB Credit Derivatives/);

# BeachStreet
return "NA Corr: Beach Street" if ($rec->{prc_ticker} =~ /^BEACHST/ &&
$rec->{prc_iname} =~ /^LL/);

return "";
}


sub excluded_stale() {
my($rec) = @_;

$is_dummy = is_dummy_curve($rec);
return $is_dummy if $is_dummy;

my($excluded) = $excluded_list->{"stale"}->{$rec->{prc_ticker}};
return $excluded if $excluded;

return "";
}


sub excluded_rating() {
my($rec) = @_;

##$is_dummy = is_dummy_curve($rec);
##return $is_dummy if ($is_dummy =~ /Dummy/);

my($excluded) = $excluded_list->{"rating"}->{$rec->{prc_ticker}};
if ($excluded) {
$desk = &get_summary_desk($rec->{prc_sector});
return $desk;
}

return "";
}

# Threshold
sub stale_threshhold() {
my($rec) = @_;

my($threshhold) = $excluded_list->{"threshhold"}->{$rec->{prc_ticker}};
if ($threshhold) {
return $threshhold;
}

return "";
}


sub get_mismatch_action() {
my($source, $sector, $pt_mismatch, $gk_mismatch, $emct_mismatch, $ca_mismatch, $storm_mismatch) = @_;
my($action);
$action = "Correct the break of:";

if ($storm_mismatch && $sector =~ /^Latin/) {
$action .= " $source/Storm.";
} else {
$action .= " EMCT" if ($emct_mismatch);
$action .= " Calypso" if ($ca_mismatch);
$action .= " PT" if ($pt_mismatch);
$action .= " Storm" if ($storm_mismatch);
$action .= " GK" if ($gk_mismatch);
$action .= ".";
}

if ($source ne "blotter") {
$action .= " Change pricing source to blotter.";
}

return $action;
}

sub get_action() {
my($source, $sector, $recovery, $recovery_lo) = @_;
my($action);

if ($source eq "gk") {
return "Change pricing source to blotter.";
}

if ($recovery < 0) {
$action = "Change $source recovery to non-zero.";
} elsif ($recovery == $recovery_lo) {
$action = "Change $source recovery to $recovery.";
} else {
$action = "Change $source recovery to (${recovery_lo}, ${recovery}).";
}
if ($source ne "blotter") {
if ($sector eq "" || $source eq "gk") {
$action .= " Change pricing source to blotter.";
} else {
$action .= " Change pricing source to blotter.";
}
}

return $action;
}

sub allow_zero_recovery() {
my($prc_sector) = @_;

return ($prc_sector =~ /Mortgage/);
}

# return -1 if there is no standard
sub get_standard_recovery() {
my($prc_sector, $prc_subord, $prc_ticker, $prc_iname, $hi_lo) = @_;

if ($prc_sector =~ /Mortgage/) {
return -1;
}

if ($prc_sector =~ /^North America/) {
if ($prc_subord =~ /^Senior Unsecured/) {
return 40;
} elsif ($prc_subord =~ /^Subordinated/) {
return 25;
}
return -1;
}

if ($prc_sector =~ /^European Single|^European Port/) {
if ($prc_subord =~ /^Senior Unsecured/) {
return 40;
} elsif ($prc_subord =~ /^Subordinated/) {
if ($hi_lo eq "HI") {
return 25;
} else {
return 20;
}
}
return -1;
}

if ($prc_sector =~ /^NSSB Credit Derivatives/) {
if ($prc_subord =~ /^Senior Unsecured/) {
return 35;
} elsif ($prc_subord =~ /^Subordinated/) {
return 30;
}
return -1;
}

return -1;
}

sub add_mismatch_summary() {
my($pt_mismatch, $gk_mismatch, $emct_mismatch, $ca_mismatch, $storm_mismatch, $storm_id) = @_;
$mismatch_summary->{"EMCT"} += 1 if ($emct_mismatch);
$mismatch_summary->{"Calypso"} += 1 if ($ca_mismatch);
$mismatch_summary->{"PT"} += 1 if ($pt_mismatch);
$mismatch_summary->{"Storm"} += 1 if ($storm_mismatch);
$mismatch_summary->{"GK"} += 1 if ($gk_mismatch);

if ($storm_mismatch) {
$storm_db = $storm_id;
$storm_db =~ s/\/.*$//;
$storm_summary->{$storm_db} += 1;
}
}

sub print_mismatch_summary() {
my($title) = @_;

print SUM_FILE "Report Summary\n\n$title\n\n";
print_system_mismatch("EMCT");
print_system_mismatch("Calypso");
print_system_mismatch("PT");
print_system_mismatch("GK");
print_system_mismatch("Storm");
print SUM_FILE "\n";
}


sub print_system_mismatch() {
my($sys_name) = @_;
$n_mismatch = $mismatch_summary->{$sys_name};
print SUM_FILE sprintf "\t%10s%6d\n", ($sys_name, $n_mismatch);
if ($sys_name eq "Storm" && $n_mismatch > 0) {
print SUM_FILE "\t\t by database:\n";
foreach $storm_db (sort keys %$storm_summary) {
$n_mismatch = $storm_summary->{$storm_db};
print SUM_FILE sprintf "\t\t%10s%6d\n", ($storm_db, $n_mismatch);
}
}
}


sub print_stale_report() {
my($rpt) = @_;

open(SFILE, "> stale_curve.${asof}.xls");

print SFILE <<EOF;
<html>
<head>
<title>Stale Curve Report</title>
</head>
<body>
<p>Report Date: $asof</p>
<table border="1" cellpadding="0" cellspacing="0">
<tr>
<td bgcolor="$light_yellow"><b>Threshold Day Count</b></td>
<td bgcolor="$light_yellow"><b>Last Closing Date</b></td>
<td bgcolor="$light_yellow"><b>User</b></td>
<td bgcolor="$light_yellow"><b>Owner</b></td>
<td bgcolor="$light_yellow"><b>Marx Ticker</b></td>
<td bgcolor="$light_yellow"><b>Marx Issuer Name</b></td>
<td bgcolor="$light_yellow"><b>CCY</b></td>
<td bgcolor="$light_yellow"><b>Subord</b></td>
<td bgcolor="$light_yellow"><b>Doc Clause</b></td>
<td bgcolor="$light_yellow"><b>Type</b></td>
<td bgcolor="$light_yellow"><b>Pricing Source</b></td>
<td bgcolor="$light_yellow"><b>Pricing Curve ID</b></td>
<td bgcolor="$light_yellow"><b>Blotter ShortCode</b></td>
<td bgcolor="$light_yellow"><b>MarkIt Name</b></td>
<td bgcolor="$light_yellow"><b>EMCT Name</b></td>
<td bgcolor="$light_yellow"><b>Calypso Name</b></td>
<td bgcolor="$light_yellow"><b>PT Name</b></td>
<td bgcolor="$light_yellow"><b>Storm Name</b></td>
<td bgcolor="$light_yellow"><b>GK Name</b></td>
<td bgcolor="$light_yellow"><b>PC Level</b></td>
<td bgcolor="$light_yellow"><b>MarkIt Level</b></td>
<td bgcolor="$light_yellow"><b>Level Diff</b></td>
<td bgcolor="$light_yellow"><b>Workdays Stale</b></td>
<td bgcolor="$light_yellow"><b>Age Bucket</b></td>
</tr>
EOF

foreach $rec (sort {$a->{prc_last_date} cmp $b->{prc_last_date} || $a->{prc_sector} cmp $b->{prc_sector} || $a->{prc_source} cmp $b->{prc_source} || $a->{prc_ticker} cmp $b->{prc_ticker} || $a->{prc_currency} cmp $b->{prc_currency} || $a->{prc_subord} cmp $b->{prc_subord} || $a->{prc_doc_id} cmp $b->{prc_doc_id}} @$rpt) {

# Set stale color
$stale_days = &diff_dates($asof, $rec->{prc_last_date});
if ($rec->{prc_last_date} eq "" || $stale_days >= 180) {
$last_color = "bgcolor=\"$light_red\"";
} elsif ($stale_days >= 90) {
$last_color = "bgcolor=\"$light_yellow\"";
} else {
$last_color = "";
}

#AP
# Set level difference color

$level_diff_color = "";
if ($rec->{diff_level_5Y} != 0 && $rec->{markit_level_5Y} == 0) {
$level_diff_color = "bgcolor=\"$light_yellow\"";
}
elsif ( $rec->{diff_level_5Y} != 0 ) {
$level_diff_color = "bgcolor=\"$light_red\"";
}


# Threshold
$stale_cutoff = &stale_threshhold($rec);
if (! $stale_cutoff) {
$stale_cutoff = $default_stale_cutoff;
}
$rec->{prc_threshhold} = $stale_cutoff;

if ( ! (($rec->{prc_last_date} eq "") || ($rec->{prc_use_level_change} =~ /Yes/)) ) {
$temp_date = $rec->{prc_last_date};
while ( $temp_date != $asof ) {
$temp_date = `/export1/app/gcdrbatch/bin/bumpweekdays "${temp_date}" 1`;
$rec->{workdays_stale}+=1;
}
}
else {
$rec->{workdays_stale} = "";
}

$rec->{prc_last_date} = "Never Closed" if ($rec->{prc_last_date} eq "");
$rec->{prc_last_date} = "Closed same level" if ($rec->{prc_use_level_change} =~ /Yes/);

if ($rec->{prc_source} eq "markit") {
$short_code = "";
$markit_id = $src_id_to_name->{$rec->{prc_ref_id}};
} else {
$short_code = $src_id_to_name->{$rec->{prc_ref_id}};
$markit_id = $rec->{markit_id};
}

$prc_sector = $rec->{prc_sector};
$desk = &get_summary_desk($prc_sector);
$stale_summary->{$desk} += 1;

$age_bucket="";
$age_bucket_color="#FFFFFF";
if (! defined($rec->{workdays_stale}) || $rec->{workdays_stale} eq "") {
$age_bucket="Never Closed";
$age_bucket_color=$light_red;
} elsif ($rec->{workdays_stale} >= 0 && $rec->{workdays_stale} <= 15) {
$age_bucket = "0-15";
$age_bucket_color=$light_yellow;
} elsif ($rec->{workdays_stale} >= 16 && $rec->{workdays_stale} <= 30) {
$age_bucket="16-30";
$age_bucket_color=$orange;
} elsif ($rec->{workdays_stale} >= 31) {
$age_bucket="31+";
$age_bucket_color=$light_red;
}

print SFILE <<EOF;
<tr>
<td>$rec->{prc_threshhold}</td>
<td $last_color>$rec->{prc_last_date}</td>
<td>$rec->{prc_last_user}</td>
<td>$rec->{prc_sector}</td>
<td>$rec->{prc_ticker}</td>
<td>$rec->{prc_iname}</td>
<td>$rec->{prc_currency}</td>
<td>$rec->{prc_subord}</td>
<td>$rec->{prc_doc_id}</td>
<td>$rec->{prc_type}</td>
<td>$rec->{prc_source}</td>
<td>$rec->{prc_curve_id}</td>
<td>$short_code</td>
<td>$markit_id</td>
<td>$rec->{emct_id}</td>
<td>$rec->{ca_id}</td>
<td>$rec->{pt_id}</td>
<td>$rec->{storm_id}</td>
<td>$rec->{gk_id}</td>
<td>$rec->{prc_level_5Y}</td>
<td>$rec->{markit_level_5Y}</td>
<td $level_diff_color>$rec->{diff_level_5Y}</td>
<td>$rec->{workdays_stale}</td>
<td bgcolor="$age_bucket_color">$age_bucket</td>
</tr>
EOF
}

print SFILE <<EOF;
</table>
</body>
</html>
EOF

close (SFILE);

$tot_mismatch = 0;
if (keys %$stale_summary > 0) {
foreach $desk (sort keys %$stale_summary) {
$n_mismatch = $stale_summary->{$desk};
print SUM_FILE sprintf "\t%35s%6d\n", ($desk,$n_mismatch);
$tot_mismatch += $n_mismatch
}
} else {
print SUM_FILE sprintf "\t%35s\n", ("None");
}
print SUM_FILE sprintf "\n\t%35s%6d\n\n", (Total,$tot_mismatch);

print SUM_FILE sprintf "Following businesses use last changed dates instead of last closed to check staleness:\n\n";
my($use_level_change) = $excluded_list->{"level_change"};
if (keys %$use_level_change > 0) {
foreach $desk (sort keys %$use_level_change) {
print SUM_FILE sprintf "\t%35s\n", ($desk);
}
} else {
print SUM_FILE sprintf "\t%35s\n", ("None");
}

}

#Marx Stale Curve Report - Product Control
sub print_prod_cntrl_report() {
my($rpt) = @_;

open(SFILE, "> stale_curve_product_control.${asof}.xls");

print SFILE <<EOF;
<html>
<head>
<title>Marx Stale Curve Report - Product Control</title>
</head>
<body>
<p>Report Date: $asof</p>
<table border="1" cellpadding="0" cellspacing="0">
<tr>
<td bgcolor="$light_yellow"><b>Threshold Day Count</b></td>
<td bgcolor="$light_yellow"><b>Last Closing Date</b></td>
<td bgcolor="$light_yellow"><b>Days Closed At Same Levels</b></td>
<td bgcolor="$light_yellow"><b>User</b></td>
<td bgcolor="$light_yellow"><b>Owner</b></td>
<td bgcolor="$light_yellow"><b>Marx Ticker</b></td>
<td bgcolor="$light_yellow"><b>Marx Issuer Name</b></td>
<td bgcolor="$light_yellow"><b>CCY</b></td>
<td bgcolor="$light_yellow"><b>Subord</b></td>
<td bgcolor="$light_yellow"><b>Doc Clause</b></td>
<td bgcolor="$light_yellow"><b>Type</b></td>
<td bgcolor="$light_yellow"><b>Pricing Source</b></td>
<td bgcolor="$light_yellow"><b>Pricing Curve ID</b></td>
<td bgcolor="$light_yellow"><b>Blotter ShortCode</b></td>
<td bgcolor="$light_yellow"><b>MarkIt Name</b></td>
<td bgcolor="$light_yellow"><b>EMCT Name</b></td>
<td bgcolor="$light_yellow"><b>Calypso Name</b></td>
<td bgcolor="$light_yellow"><b>PT Name</b></td>
<td bgcolor="$light_yellow"><b>Storm Name</b></td>
<td bgcolor="$light_yellow"><b>GK Name</b></td>
<td bgcolor="$light_yellow"><b>PC 3M</b></td>
<td bgcolor="$light_yellow"><b>PC 6M</b></td>
<td bgcolor="$light_yellow"><b>PC 1Y</b></td>
<td bgcolor="$light_yellow"><b>PC 2Y</b></td>
<td bgcolor="$light_yellow"><b>PC 3Y</b></td>
<td bgcolor="$light_yellow"><b>PC 4Y</b></td>
<td bgcolor="$light_yellow"><b>PC 5Y</b></td>
<td bgcolor="$light_yellow"><b>PC 7Y</b></td>
<td bgcolor="$light_yellow"><b>PC 10Y</b></td>
<td bgcolor="$light_yellow"><b>PC 15Y</b></td>
<td bgcolor="$light_yellow"><b>PC 20Y</b></td>
<td bgcolor="$light_yellow"><b>PC 30Y</b></td>
<td bgcolor="$light_yellow"><b>Markit 3M</b></td>
<td bgcolor="$light_yellow"><b>Markit 6M</b></td>
<td bgcolor="$light_yellow"><b>Markit 1Y</b></td>
<td bgcolor="$light_yellow"><b>Markit 2Y</b></td>
<td bgcolor="$light_yellow"><b>Markit 3Y</b></td>
<td bgcolor="$light_yellow"><b>Markit 4Y</b></td>
<td bgcolor="$light_yellow"><b>Markit 5Y</b></td>
<td bgcolor="$light_yellow"><b>Markit 7Y</b></td>
<td bgcolor="$light_yellow"><b>Markit 10Y</b></td>
<td bgcolor="$light_yellow"><b>Markit 15Y</b></td>
<td bgcolor="$light_yellow"><b>Markit 20Y</b></td>
<td bgcolor="$light_yellow"><b>Markit 30Y</b></td>
<td bgcolor="$light_yellow"><b>Diff 3M</b></td>
<td bgcolor="$light_yellow"><b>Diff 6M</b></td>
<td bgcolor="$light_yellow"><b>Diff 1Y</b></td>
<td bgcolor="$light_yellow"><b>Diff 2Y</b></td>
<td bgcolor="$light_yellow"><b>Diff 3Y</b></td>
<td bgcolor="$light_yellow"><b>Diff 4Y</b></td>
<td bgcolor="$light_yellow"><b>Diff 5Y</b></td>
<td bgcolor="$light_yellow"><b>Diff 7Y</b></td>
<td bgcolor="$light_yellow"><b>Diff 10Y</b></td>
<td bgcolor="$light_yellow"><b>Diff 15Y</b></td>
<td bgcolor="$light_yellow"><b>Diff 20Y</b></td>
<td bgcolor="$light_yellow"><b>Diff 30Y</b></td>
</tr>
EOF

foreach $rec (sort {$a->{prc_last_date_prod_ctrl} cmp $b->{prc_last_date_prod_ctrl} || $a->{prc_sector} cmp $b->{prc_sector} || $a->{prc_source} cmp $b->{prc_source} || $a->{prc_ticker} cmp $b->{prc_ticker} || $a->{prc_currency} cmp $b->{prc_currency} || $a->{prc_subord} cmp $b->{prc_subord} || $a->{prc_doc_id} cmp $b->{prc_doc_id}} @$rpt) {

# Set stale color
$stale_days = &diff_dates($asof, $rec->{prc_last_date_prod_ctrl});
if ($rec->{prc_last_date_prod_ctrl} eq "" || $stale_days >= 180) {
$last_color = "bgcolor=\"$light_red\"";
} elsif ($stale_days >= 90) {
$last_color = "bgcolor=\"$light_yellow\"";
} else {
$last_color = "";
}

# #AP
# # Set level difference color
# #$level_diff_color = $rec->{diff_level_5Y} == 0 ? "" : "bgcolor=\"$light_red\"";
# if ($rec->{diff_level_5Y} != 0 && $rec->{markit_level_5Y} == 0) {
# $level_diff_color = "bgcolor=\"$light_yellow\"";
# }
# elsif ($rec->{diff_level_5Y} != 0) {
# }

# Threshold
$stale_cutoff = &stale_threshhold($rec);
if (! $stale_cutoff) {
$stale_cutoff = $default_stale_cutoff;
}
$rec->{prc_threshhold} = $stale_cutoff;

$rec->{prc_last_date_prod_ctrl} = "Never Closed" if ($rec->{prc_last_date_prod_ctrl} eq "");
$rec->{prc_last_date_prod_ctrl} = "Closed same level" if ($rec->{prc_use_level_change_prod_ctrl} =~ /Yes/);

if ($rec->{prc_source} eq "markit") {
$short_code = "";
$markit_id = $src_id_to_name->{$rec->{prc_ref_id}};
} else {
$short_code = $src_id_to_name->{$rec->{prc_ref_id}};
$markit_id = $rec->{markit_id};
}

$prc_sector = $rec->{prc_sector};
$desk = &get_summary_desk($prc_sector);
$stale_summary->{$desk} += 1;

print SFILE <<EOF;
<tr>
<td>$rec->{prc_threshhold}</td>
<td $last_color>$rec->{prc_last_date_prod_ctrl}</td>
<td>$rec->{consecutive_days_closed_same}</td>
<td>$rec->{prc_last_user}</td>
<td>$rec->{prc_sector}</td>
<td>$rec->{prc_ticker}</td>
<td>$rec->{prc_iname}</td>
<td>$rec->{prc_currency}</td>
<td>$rec->{prc_subord}</td>
<td>$rec->{prc_doc_id}</td>
<td>$rec->{prc_type}</td>
<td>$rec->{prc_source}</td>
<td>$rec->{prc_curve_id}</td>
<td>$short_code</td>
<td>$markit_id</td>
<td>$rec->{emct_id}</td>
<td>$rec->{ca_id}</td>
<td>$rec->{pt_id}</td>
<td>$rec->{storm_id}</td>
<td>$rec->{gk_id}</td>
<td>$rec->{prc_level_3M}</td>
<td>$rec->{prc_level_6M}</td>
<td>$rec->{prc_level_1Y}</td>
<td>$rec->{prc_level_2Y}</td>
<td>$rec->{prc_level_3Y}</td>
<td>$rec->{prc_level_4Y}</td>
<td>$rec->{prc_level_5Y}</td>
<td>$rec->{prc_level_7Y}</td>
<td>$rec->{prc_level_10Y}</td>
<td>$rec->{prc_level_15Y}</td>
<td>$rec->{prc_level_20Y}</td>
<td>$rec->{prc_level_30Y}</td>
<td>$rec->{markit_level_3M}</td>
<td>$rec->{markit_level_6M}</td>
<td>$rec->{markit_level_1Y}</td>
<td>$rec->{markit_level_2Y}</td>
<td>$rec->{markit_level_3Y}</td>
<td>$rec->{markit_level_4Y}</td>
<td>$rec->{markit_level_5Y}</td>
<td>$rec->{markit_level_7Y}</td>
<td>$rec->{markit_level_10Y}</td>
<td>$rec->{markit_level_15Y}</td>
<td>$rec->{markit_level_20Y}</td>
<td>$rec->{markit_level_30Y}</td>
<td>$rec->{diff_level_3M}</td>
<td>$rec->{diff_level_6M}</td>
<td>$rec->{diff_level_1Y}</td>
<td>$rec->{diff_level_2Y}</td>
<td>$rec->{diff_level_3Y}</td>
<td>$rec->{diff_level_4Y}</td>
<td>$rec->{diff_level_5Y}</td>
<td>$rec->{diff_level_7Y}</td>
<td>$rec->{diff_level_10Y}</td>
<td>$rec->{diff_level_15Y}</td>
<td>$rec->{diff_level_20Y}</td>
<td>$rec->{diff_level_30Y}</td>
</tr>
EOF
}


print SFILE <<EOF;
</table>
</body>
</html>
EOF

close (SFILE);

$tot_mismatch = 0;
if (keys %$stale_summary > 0) {
foreach $desk (sort keys %$stale_summary) {
$n_mismatch = $stale_summary->{$desk};
print SUM_FILE sprintf "\t%35s%6d\n", ($desk,$n_mismatch);
$tot_mismatch += $n_mismatch
}
} else {
print SUM_FILE sprintf "\t%35s\n", ("None");
}
print SUM_FILE sprintf "\n\t%35s%6d\n\n", (Total,$tot_mismatch);
}


sub print_excluded_report() {
my($rpt, $title) = @_;

my($excluded_summary) = {};
open(SFILE, "> ${title}_excluded.${asof}.xls");

print SFILE <<EOF;
<html>
<head>
<title>$title excluded report</title>
</head>
<body>
<table border="1" cellpadding="0" cellspacing="0">
<tr>
<td bgcolor="$light_yellow"><b>Reason</b></td>
<td bgcolor="$light_yellow"><b>Owner</b></td>
<td bgcolor="$light_yellow"><b>Marx Ticker</b></td>
<td bgcolor="$light_yellow"><b>Marx Issuer Name</b></td>
<td bgcolor="$light_yellow"><b>CCY</b></td>
<td bgcolor="$light_yellow"><b>Subord</b></td>
<td bgcolor="$light_yellow"><b>Doc Clause</b></td>
<td bgcolor="$light_yellow"><b>Type</b></td>
<td bgcolor="$light_yellow"><b>Pricing Source</b></td>
<td bgcolor="$light_yellow"><b>Pricing Curve ID</b></td>
<td bgcolor="$light_yellow"><b>Last Close Date</b></td>
<td bgcolor="$light_yellow"><b>Username</b></td>
<td bgcolor="$light_yellow"><b>Marx Recovery</b></td>
<td bgcolor="$light_yellow"><b>Blotter ShortCode</b></td>
<td bgcolor="$light_yellow"><b>MarkIt Name</b></td>
<td bgcolor="$light_yellow"><b>Mark-It Recovery</b></td>
<td bgcolor="$light_yellow"><b>EMCT Name</b></td>
<td bgcolor="$light_yellow"><b>EMCT Recovery</b></td>
<td bgcolor="$light_yellow"><b>Calypso Name</b></td>
<td bgcolor="$light_yellow"><b>Calypso Recovery</b></td>
<td bgcolor="$light_yellow"><b>PT Name</b></td>
<td bgcolor="$light_yellow"><b>PT Recovery</b></td>
<td bgcolor="$light_yellow"><b>Storm Name</b></td>
<td bgcolor="$light_yellow"><b>Storm Recovery</b></td>
<td bgcolor="$light_yellow"><b>GK Name</b></td>
<td bgcolor="$light_yellow"><b>GK Recovery</b></td>
</tr>
EOF

foreach $rec (sort {$a->{excluded} cmp $b->{excluded} || $a->{prc_sector} cmp $b->{prc_sector} || $a->{prc_source} cmp $b->{prc_source} || $a->{prc_ticker} cmp $b->{prc_ticker} || $a->{prc_currency} cmp $b->{prc_currency} || $a->{prc_subord} cmp $b->{prc_subord} || $a->{prc_doc_id} cmp $b->{prc_doc_id}} @$rpt) {


if ($rec->{prc_source} eq "markit") {
$short_code = "";
$markit_id = $src_id_to_name->{$rec->{prc_ref_id}};
} else {
$short_code = $src_id_to_name->{$rec->{prc_ref_id}};
$markit_id = $rec->{markit_id};
}

$prc_sector