diff --git a/cfg/cfg.d/z_reports.pl b/cfg/cfg.d/z_reports.pl index a36485b..b1a7291 100644 --- a/cfg/cfg.d/z_reports.pl +++ b/cfg/cfg.d/z_reports.pl @@ -17,6 +17,8 @@ $c->{plugins}{"Screen::Report::User"}{params}{disable} = 0; $c->{plugins}{"Screen::Report::User"}{params}{custom} = 1; +$c->{reports}->{csv_utf8_bom} = 1; + #set config for default eprint report $c->{search}->{eprint_report} = $c->{search}->{advanced}; #use the advanced search form as the default eprint report search diff --git a/lib/lang/en/phrases/reports.xml b/lib/lang/en/phrases/reports.xml index 680214e..1972d5a 100644 --- a/lib/lang/en/phrases/reports.xml +++ b/lib/lang/en/phrases/reports.xml @@ -4,6 +4,8 @@ Loading report... + | + Reports No available reports @@ -19,6 +21,9 @@
+Select Report: +Select Export Format: + Example Articles diff --git a/lib/plugins/EPrints/Plugin/Export/Grid2.pm b/lib/plugins/EPrints/Plugin/Export/Grid2.pm index d3cb84e..e600551 100644 --- a/lib/plugins/EPrints/Plugin/Export/Grid2.pm +++ b/lib/plugins/EPrints/Plugin/Export/Grid2.pm @@ -17,325 +17,376 @@ $EPrints::Plugin::Import::DISABLE = 1; sub new { - my( $class, %opts ) = @_; + my( $class, %opts ) = @_; - my $self = $class->SUPER::new( %opts ); + my $self = $class->SUPER::new( %opts ); - $self->{name} = "Grid 2 (abstract)"; - $self->{accept} = [ 'dataobj/*', 'list/*', ]; - $self->{visible} = "none"; - $self->{advertise} = 0; - return $self; + $self->{name} = "Grid 2 (abstract)"; + $self->{accept} = [ 'dataobj/*', 'list/*', ]; + $self->{visible} = "none"; + $self->{advertise} = 0; + return $self; } sub fields { - my( $self, $dataset ) = @_; - - # skip compound, subobjects - #return grep { !$_->is_virtual } $dataset->fields; - - my @fieldnames; - foreach my $f ( $dataset->fields ) - { - if( !$f->is_virtual ) - { - push @fieldnames, $f->name; - } - } - return \@fieldnames; + my( $self, $dataset ) = @_; + + # skip compound, subobjects + # return grep { !$_->is_virtual } $dataset->fields; + + my @fieldnames; + foreach my $f ( $dataset->fields ) + { + if( !$f->is_virtual ) + { + push @fieldnames, $f->name; + } + } + return \@fieldnames; } sub header_row { - my( $self, %opts ) = @_; + my( $self, %opts ) = @_; + + my $fields = $opts{fields} ||= [$self->fields($opts{list}->{dataset})]; + my $ds = $opts{list}->{dataset}; + + my @names; + + # option to not use phrases and just use field names + my $use_ids = $opts{plugin}->{use_ids} ||= 0; + if( $use_ids ) + { + foreach my $f (@$fields) + { + if( defined $opts{custom_export} && defined $opts{custom_export}->{$f} ) + { + push @names, $f; + } + else + { + my $field = EPrints::Utils::field_from_config_string( $ds, $f ); + if( $field->isa( "EPrints::MetaField::Multipart" ) ) + { + my $name = $field->name; + if( $field->isa( "EPrints::MetaField::Name" ) ) + { + foreach my $bit ( $field->get_input_bits() ) + { + push @names,$name . '.' . $bit; + } + } + else + { + push @names, map { + $name . '.' . $_->{sub_name} + } @{$field->property("fields_cache")}; + } + } + else + { + push @names, $field->name; + } + } + } + return @names; + } - my $fields = $opts{fields} ||= [$self->fields($opts{list}->{dataset})]; - my $ds = $opts{list}->{dataset}; + # else we use phrases + foreach my $f (@$fields) + { + if( defined $opts{custom_export} && defined $opts{custom_export}->{$f} ) + { + push @names, $ds->repository->phrase( "exportfieldoptions:$f" ); + } + else + { + my $field = EPrints::Utils::field_from_config_string( $ds, $f ); - my @names; - foreach my $f (@$fields) - { - if( defined $opts{custom_export} && defined $opts{custom_export}->{$f} ) + if ($field->isa("EPrints::MetaField::Multipart")) + { + my $parent_name = $field->display_name( $field->repository ); + if( $field->isa( "EPrints::MetaField::Name" )) # need to deal with legacy phrase id's { - push @names, $ds->repository->html_phrase( "exportfieldoptions:$f" ); + foreach my $bit ( $field->get_input_bits() ) + { + $bit = "given_names" if( $bit eq "given" ); + $bit = "family_names" if( $bit eq "family" ); + my $custom_phrase = $field->name . "_" . $bit; + if( $ds->repository->get_lang->has_phrase( $custom_phrase ) ) # allow a custom phrase to be used + { + push @names, $ds->repository->phrase( $custom_phrase ); + } + else + { + push @names, $parent_name . ": " . $ds->repository->phrase( "lib/metafield:".$bit ); + } + } } - else - { - my $field = EPrints::Utils::field_from_config_string( $ds, $f ); - - if ($field->isa("EPrints::MetaField::Multipart")) - { - my $parent_name = $field->render_name; - if( $field->isa( "EPrints::MetaField::Name" )) #need to deal with legacy phrase id's - { - foreach my $bit ( $field->get_input_bits() ) - { - $bit = "given_names" if( $bit eq "given" ); - $bit = "family_names" if( $bit eq "family" ); - my $custom_phrase = $field->name . "_" . $bit; - if( $ds->repository->get_lang->has_phrase( $custom_phrase ) ) #allow a custom phrase to be used - { - push @names, $ds->repository->html_phrase( $custom_phrase ); - } - else - { - push @names, $parent_name . ": " . $ds->repository->html_phrase( "lib/metafield:".$bit ); - } - } - } - else - { - my $name = $field->name; - push @names, map { - $name . '.' . $_->{sub_name} - } @{$field->property("fields_cache")}; - } - } - elsif( $field->isa("EPrints::MetaField::Compound" ) ) - { - foreach my $sub_field (@{$field->property("fields_cache")}) - { - my $custom_phrase = $field->name . "_" . $sub_field->name; - if( $ds->repository->get_lang->has_phrase( $custom_phrase ) ) #allow a custom phrase to be used - { - push @names, $ds->repository->html_phrase( $custom_phrase ); - } - else - { - push @names, $field->render_name . ": " . $sub_field->render_name; - } - } - } - else - { - push @names, $field->render_name; - } - } - } - return @names; + else + { + my $name = $field->name; + push @names, map { + $name . '.' . $_->{sub_name} + } @{$field->property("fields_cache")}; + } + } + elsif( $field->isa("EPrints::MetaField::Compound" ) ) + { + foreach my $sub_field (@{$field->property("fields_cache")}) + { + my $custom_phrase = $field->name . "_" . $sub_field->name; + if( $ds->repository->get_lang->has_phrase( $custom_phrase ) ) # allow a custom phrase to be used + { + push @names, $ds->repository->phrase( $custom_phrase ); + } + else + { + push @names, $field->display_name( $field->repository ) . ": " . $sub_field->display_name( $sub_field->repository ); + } + } + } + else + { + push @names, $field->display_name( $field->repository ); + } + } + } + return @names; } sub dataobj_to_rows { - my( $self, $dataobj, %opts ) = @_; + my( $self, $dataobj, %opts ) = @_; - my $main_dataobj = $dataobj; #store dataobj for future reference + my $main_dataobj = $dataobj; # store dataobj for future reference - my $fields = $opts{fields} || [$self->fields($dataobj->{dataset})]; - my $ds = $opts{list}->{dataset}; + my $fields = $opts{fields} || [$self->fields($dataobj->{dataset})]; + my $ds = $opts{list}->{dataset}; - my @rows = ([]); - foreach my $fname (@$fields) - { - #reset dataobj to main dataobj - $dataobj = $main_dataobj; + my @rows = ([]); + foreach my $fname (@$fields) + { + #reset dataobj to main dataobj + $dataobj = $main_dataobj; - #get the field from the id - my $field; - my @fnames = split( /\./, $fname ); - my $sub_dataobj_values = []; - if( scalar( @fnames > 1 ) ) #a field of another dataset, e.g. documents.content + # get the field from the id + my $field; + my @fnames = split( /\./, $fname ); + my $sub_dataobj_values = []; + if( scalar( @fnames > 1 ) ) # a field of another dataset, e.g. documents.content { - $field = $ds->get_field( $fnames[0] ); #first get the field - if( $field->is_type( "subobject", "itemref" ) ) #if the field belongs to another dataset - { - my $sub_ds_id = $field->get_property( "datasetid" ); - my $multiple = $field->get_property( "multiple" ); - if( $multiple ) - { - my @sub_dataobjs; - #get the dataobjs of this field - if( $sub_ds_id eq "document" ) #documents represent a special case of sub object - we don't want volatile documents (probably) - { - @sub_dataobjs = $dataobj->get_all_documents; - } - else - { - foreach my $sub_obj ( @{$dataobj->value( $fnames[0] )} ) - { - push @sub_dataobjs, $field->get_item( $dataobj->repository, $sub_obj ); - } - } - - #and build up an array of these sub dataobj's values - foreach my $obj ( @sub_dataobjs ) #get the values we are requesting of the dataobjects - { - #check for a custom renderer - my $value; - if( defined $opts{custom_export} && defined $opts{custom_export}->{$fname} ) - { - $value = $opts{custom_export}->{$fname}->( $obj, $opts{plugin} ); - } - else - { - $field = EPrints::Utils::field_from_config_string( $obj->dataset, $fnames[1] ); - if( $field->get_property( "virtual" ) ) #virtual fields need rendering - { - $value = EPrints::Utils::tree_to_utf8( $obj->render_value( $fnames[1] ) ); - } - else #regular field values can simply be retrieved - { - $value = $field->get_value( $obj ); - } - } - push @{$sub_dataobj_values}, $value; - } - } - else #we only have one sub-object, - { - my $sub_obj = $field->get_item( $dataobj->repository, $dataobj->value( $fnames[0] ) ); #get the subobject - $field = EPrints::Utils::field_from_config_string( $sub_obj->dataset, $fnames[1] ); #get the subobjects field - my $value = $field->get_value( $sub_obj ); #get the subobjects value for this field - push @{$sub_dataobj_values}, $value; - } - } - } - - my $i = @{$rows[0]}; - my $_rows; - if( EPrints::Utils::is_set( $field ) ) #we already have our values - { - if( scalar @{$sub_dataobj_values} > 0 ) - { - $_rows = $self->value_to_rows($field, $sub_dataobj_values, $dataobj); - } - else #there's no results, but we still need to add an empty cell to the spreadsheet - { - $_rows = $self->value_to_rows($field, undef); - } - } - else #we need to retrieve our values for this field from our dataobj (or sub_dataobj) - { - my $value; - if( defined $opts{custom_export} && defined $opts{custom_export}->{$fname} ) #we have a custom exporter - { - $value = $opts{custom_export}->{$fname}->( $dataobj, $opts{plugin} ); - $_rows = $self->custom_value_to_rows( $value ); - } - else #just get the field's usual value - { - $field = EPrints::Utils::field_from_config_string( $ds, $fname ); - if( $field->get_property( "virtual" ) ) #virtual fields need rendering - { - $value = EPrints::Utils::tree_to_utf8( $dataobj->render_value( $fname ) ); - } - else #regular field values can simply be retrieved - { - $value = $field->get_value( $dataobj ); - } - $_rows = $self->value_to_rows($field, $value, $dataobj); - } - } - - foreach my $j (0..$#$_rows) - { - foreach my $_i (0..$#{$_rows->[$j]}) - { - $rows[$j][$i+$_i] = $_rows->[$j][$_i]; - } - } - } - - # generate complete rows - if($opts{plugin}->param( "multiline_repeat" )) #we want each column to repeat for each row - { - foreach my $i (0..(scalar @rows)-1) - { - foreach my $j (0..$#{$rows[0]}) - { - $rows[$i][$j] ||= $rows[0][$j]; - } - } - } - else #we don't want repeating values in the columns - { - for(@rows) { - $_->[0] = $rows[0][0]; #first element of this array equals the first element of the first row - $_->[$#{$rows[0]}] ||= undef; - } - - } - - return \@rows; -} - -sub value_to_rows -{ - my ($self, $field, $value, $dataobj) = @_; - - my @rows; - - if (ref($value) eq "ARRAY") - { - $value = [$field->empty_value] if !@$value; - @rows = map { $self->value_to_rows($field, $_, $dataobj)->[0] } @$value; - } - elsif ($field->isa("EPrints::MetaField::Multipart")) - { - if( $field->isa( "EPrints::MetaField::Name" )) #need to deal with legacy phrase id's + $field = $ds->get_field( $fnames[0] ); # first get the field + if( $field->is_type( "subobject", "itemref" ) ) # if the field belongs to another dataset + { + my $sub_ds_id = $field->get_property( "datasetid" ); + my $multiple = $field->get_property( "multiple" ); + if( $multiple ) { - my @bit_values; - foreach my $bit ( $field->get_input_bits() ) + my @sub_dataobjs; + # get the dataobjs of this field + if( $sub_ds_id eq "document" ) # documents represent a special case of sub object - we don't want volatile documents (probably) + { + @sub_dataobjs = $dataobj->get_all_documents; + } + else + { + foreach my $sub_obj ( @{$dataobj->value( $fnames[0] )} ) { - push @bit_values, $value->{$bit}; - } - push @rows, \@bit_values; - } - else - { - push @rows, [map { $value->{$_->{sub_name}} } @{$field->property("fields_cache")}]; - } - } - elsif ($field->isa("EPrints::MetaField::Compound")) - { - my @sub_values; - foreach my $key (keys %{$value}) - { - push @sub_values, $value->{$key}; - } - push @rows, \@sub_values; - } - elsif( $field->isa("EPrints::MetaField::Subject")) + push @sub_dataobjs, $field->get_item( $dataobj->repository, $sub_obj ); + } + } + + # and build up an array of these sub dataobj's values + foreach my $obj ( @sub_dataobjs ) # get the values we are requesting of the dataobjects + { + # check for a custom renderer + my $value; + if( defined $opts{custom_export} && defined $opts{custom_export}->{$fname} ) + { + $value = $opts{custom_export}->{$fname}->( $obj, $opts{plugin} ); + } + else + { + $field = EPrints::Utils::field_from_config_string( $obj->dataset, $fnames[1] ); + if( $field->get_property( "virtual" ) ) # virtual fields need rendering + { + $value = EPrints::Utils::tree_to_utf8( $obj->render_value( $fnames[1] ) ); + } + else # regular field values can simply be retrieved + { + $value = $field->get_value( $obj ); + } + } + push @{$sub_dataobj_values}, $value; + } + } + else # we only have one sub-object, + { + my $sub_obj; + if( ref( $field ) eq "EPrints::MetaField::Subobject" ) + { + $sub_obj = $dataobj->value( $fnames[0] ); + } + else # do it the original way (assuming this ever worked...? + { + $sub_obj = $field->get_item( $dataobj->repository, $dataobj->value( $fnames[0] ) ); # get the subobject + } + + $field = EPrints::Utils::field_from_config_string( $sub_obj->dataset, $fnames[1] ); # get the subobjects field + my $value = $field->get_value( $sub_obj ); # get the subobjects value for this field + push @{$sub_dataobj_values}, $value; + } + } + } + + my $i = @{$rows[0]}; + my $_rows; + if( EPrints::Utils::is_set( $field ) ) # we already have our values + { + if( scalar @{$sub_dataobj_values} > 0 ) + { + $_rows = $self->value_to_rows($field, $sub_dataobj_values, $dataobj); + } + else # there's no results, but we still need to add an empty cell to the spreadsheet + { + $_rows = $self->value_to_rows($field, undef); + } + } + else # we need to retrieve our values for this field from our dataobj (or sub_dataobj) { - if( $value ne "" ) + my $value; + if( defined $opts{custom_export} && defined $opts{custom_export}->{$fname} ) # we have a custom exporter + { + $value = $opts{custom_export}->{$fname}->( $dataobj, $opts{plugin} ); + $_rows = $self->custom_value_to_rows( $value ); + } + else # just get the field's usual value + { + $field = EPrints::Utils::field_from_config_string( $ds, $fname ); + if( $field->get_property( "virtual" ) ) # virtual fields need rendering { - push @rows, [$field->render_single_value( $field->repository, $value )]; + $value = EPrints::Utils::tree_to_utf8( $dataobj->render_value( $fname ) ); } - else + else # regular field values can simply be retrieved { - push @rows, [$value]; + $value = $field->get_value( $dataobj ); } + $_rows = $self->value_to_rows($field, $value, $dataobj); + } } - elsif( !$field->isa("EPrints::MetaField::Subobject") && $field->is_virtual ) - { - push @rows, [$dataobj->render_value( $field->name )]; - } - else - { - push @rows, [$value]; - } - - return \@rows; -} -#used for custom exports that might return a field or an array (but aren't necesarily associated with a field!) -sub custom_value_to_rows -{ - my ($self, $value) = @_; + foreach my $j (0..$#$_rows) + { + foreach my $_i (0..$#{$_rows->[$j]}) + { + $rows[$j][$i+$_i] = $_rows->[$j][$_i]; + } + } + } - my @rows; + # generate complete rows + if($opts{plugin}->param( "multiline_repeat" )) # we want each column to repeat for each row + { + foreach my $i (0..(scalar @rows)-1) + { + foreach my $j (0..$#{$rows[0]}) + { + $rows[$i][$j] ||= $rows[0][$j]; + } + } + } + else # we don't want repeating values in the columns + { + for(@rows) { + $_->[0] = $rows[0][0]; # first element of this array equals the first element of the first row + $_->[$#{$rows[0]}] ||= undef; + } + + } + + return \@rows; +} - if (ref($value) eq "ARRAY") +sub value_to_rows +{ + my ($self, $field, $value, $dataobj) = @_; + + my @rows; + + if (ref($value) eq "ARRAY") + { + $value = [$field->empty_value] if !@$value; + @rows = map { $self->value_to_rows($field, $_, $dataobj)->[0] } @$value; + } + elsif ($field->isa("EPrints::MetaField::Multipart")) + { + if( $field->isa( "EPrints::MetaField::Name" )) # need to deal with legacy phrase id's { - @rows = map { $self->custom_value_to_rows($_)->[0] } @$value; + my @bit_values; + foreach my $bit ( $field->get_input_bits() ) + { + push @bit_values, $value->{$bit}; + } + push @rows, \@bit_values; } else { - push @rows, [$value]; + push @rows, [map { $value->{$_->{sub_name}} } @{$field->property("fields_cache")}]; + } + } + elsif ($field->isa("EPrints::MetaField::Compound")) + { + my @sub_values; + foreach my $key (keys %{$value}) + { + push @sub_values, $value->{$key}; } + push @rows, \@sub_values; + } + elsif( $field->isa("EPrints::MetaField::Subject")) + { + if( $value ne "" ) + { + push @rows, [EPrints::Utils::tree_to_utf8( $field->render_single_value( $field->repository, $value ) )]; + } + else + { + push @rows, [$value]; + } + } + elsif( !$field->isa("EPrints::MetaField::Subobject") && $field->is_virtual ) + { + #push @rows, [$dataobj->render_value( $field->name )]; + push @rows, [$value]; + } + else + { + push @rows, [$value]; + } + + return \@rows; +} + +# used for custom exports that might return a field or an array (but aren't necesarily associated with a field!) +sub custom_value_to_rows +{ + my ($self, $value) = @_; + + my @rows; + + if (ref($value) eq "ARRAY") + { + @rows = map { $self->custom_value_to_rows($_)->[0] } @$value; + } + else + { + push @rows, [$value]; + } - return \@rows; + return \@rows; } diff --git a/lib/plugins/EPrints/Plugin/Export/Report/CSV.pm b/lib/plugins/EPrints/Plugin/Export/Report/CSV.pm index cbf7b5d..02d98b6 100644 --- a/lib/plugins/EPrints/Plugin/Export/Report/CSV.pm +++ b/lib/plugins/EPrints/Plugin/Export/Report/CSV.pm @@ -20,9 +20,23 @@ sub new return $self; } +sub initialise_fh +{ + my( $plugin, $fh ) = @_; + + $plugin->SUPER::initialise_fh( $fh ); + + # include UTF-8 byte order marker so Excel knows how to display the conten + my $repo = $plugin->repository; + if( $repo->config( "reports", "csv_utf8_bom" ) ) + { + print $fh chr(65279); + } +} + sub output_list { - my( $plugin, %opts ) = @_; + my( $plugin, %opts ) = @_; my $repo = $plugin->repository; diff --git a/lib/plugins/EPrints/Plugin/Export/Report/JSON.pm b/lib/plugins/EPrints/Plugin/Export/Report/JSON.pm index 5baa714..67e044b 100644 --- a/lib/plugins/EPrints/Plugin/Export/Report/JSON.pm +++ b/lib/plugins/EPrints/Plugin/Export/Report/JSON.pm @@ -154,30 +154,38 @@ sub _epdata_to_json foreach my $fieldname ( @{$self->{exportfields}} ) { - my @fnames = split( /\./, $fieldname ); - if( scalar( @fnames > 1 ) ) #a field of another dataset, e.g. documents.content + my @fnames = split( /\./, $fieldname ); + if( scalar( @fnames > 1 ) ) #a field of another dataset, e.g. documents.content + { + my $field = $self->{dataset}->get_field( $fnames[0] ); #first get the field + if( $field->is_type( "subobject", "itemref" ) ) #if thee field belongs to another dataset { - my $field = $self->{dataset}->get_field( $fnames[0] ); #first get the field - if( $field->is_type( "subobject", "itemref" ) ) #if thee field belongs to another dataset - { - my $subsubdata = $subdata->{$fnames[0]} || []; #create an array for the sub ojects - my $dataobjs= $epdata->value( $fnames[0] ); #get the dataobjects this field represents - for (my $i=0; $i < scalar( @{$dataobjs} ); $i++) - { - my $obj = @{$dataobjs}[$i]; #get the value from the dataobject - my $value = $obj->value( $fnames[1] ); - next if !EPrints::Utils::is_set( $value ); - - my $subsubsubdata = $subdata->{$fnames[0]}[$i] || {}; - $subsubsubdata->{$fnames[1]} = $value; - - $subdata->{$fnames[0]}[$i] = $subsubsubdata; - } - } - } - else - { - my $field = $self->{dataset}->get_field( $fieldname ); + my $subsubdata = $subdata->{$fnames[0]} || []; #create an array for the sub ojects + my $dataobjs= $epdata->value( $fnames[0] ); #get the dataobjects this field represents + for (my $i=0; $i < scalar( @{$dataobjs} ); $i++) + { + my $obj = @{$dataobjs}[$i]; #get the value from the dataobject + my $value = $obj->value( $fnames[1] ); + next if !EPrints::Utils::is_set( $value ); + + my $subsubsubdata = $subdata->{$fnames[0]}[$i] || {}; + $subsubsubdata->{$fnames[1]} = $value; + + $subdata->{$fnames[0]}[$i] = $subsubsubdata; + } + } + } + else + { + if( defined $repo->config( $self->{report}->{export_conf}, "custom_export" ) && + exists $repo->config( $self->{report}->{export_conf}, "custom_export" )->{$fieldname} ) + { + my $value = $repo->config( $self->{report}->{export_conf}, "custom_export" )->{$fieldname}->( $epdata, $self->{report} ); + $subdata->{$fieldname} = $value; + } + else + { + my $field = $self->{dataset}->get_field( $fieldname ); next if !$field->get_property( "export_as_xml" ); my $value = $field->get_value( $epdata ); if( defined $repo->config( $self->{report}->{export_conf}, "custom_export" ) && @@ -191,7 +199,8 @@ sub _epdata_to_json } next if !EPrints::Utils::is_set( $value ); $subdata->{$field->get_name} = $value; - } + } + } } $subdata->{uri} = $epdata->uri; diff --git a/lib/plugins/EPrints/Plugin/Screen/Report.pm b/lib/plugins/EPrints/Plugin/Screen/Report.pm index 62d6d86..b444869 100644 --- a/lib/plugins/EPrints/Plugin/Screen/Report.pm +++ b/lib/plugins/EPrints/Plugin/Screen/Report.pm @@ -113,7 +113,13 @@ sub _create_search return if ! defined $report_plugin->{searchdatasetid}; $self->{processor}->{report_plugin} = $report_plugin; - my $report_ds = $session->dataset( $report_plugin->{searchdatasetid} ); + my $searchdatasetid = $report_plugin->{searchdatasetid}; + if( defined $report_plugin->param("searchdatasetid") ) + { + $searchdatasetid = $report_plugin->param("searchdatasetid"); + } + + my $report_ds = $session->dataset( $searchdatasetid ); if( defined $report_ds ) { $self->{processor}->{datasetid} = $report_ds->base_id; @@ -574,8 +580,8 @@ sub render_splash_page $form->appendChild( $self->render_controls( 1 ) ); #add each report to the select component and generate search form if required - my $report_select = $repo->make_element( "select", name=>"report", id=>"select_report" ); - my %search_forms; + my $report_select = $repo->make_element( "select", name=>"report", id=>"select_report", 'aria-labelledby' => "report_select_label" ); + my @search_forms; my $custom_reports = 0; #foreach my $report_plugin ( @plugins ) foreach my $report_plugin ( sort { $a->get_subtype cmp $b->get_subtype } @plugins ) @@ -600,9 +606,17 @@ sub render_splash_page $option->appendChild( $report_plugin->render_title ); $report_select->appendChild( $option ); + # now we've added to the select, do we need to render a search form + next if (grep { $formid eq $_ } @search_forms ); + #create search form #get report dataset and appropriate search config - my $report_ds = $repo->dataset( $report_plugin->{searchdatasetid} ); + my $searchdatasetid = $report_plugin->{searchdatasetid}; + if( defined $report_plugin->param("searchdatasetid") ) + { + $searchdatasetid = $report_plugin->param("searchdatasetid"); + } + my $report_ds = $repo->dataset( $searchdatasetid ); my $sconf = $report_ds->search_config( $report_plugin->{sconf} ) ; #my $search = EPrints::Search->new( # keep_cache => 1, @@ -626,23 +640,30 @@ sub render_splash_page #generate the form my $frag = $self->render_search_fields( $searchexp, $formid ); - $search_forms{$formid} = $frag unless exists $search_forms{$formid}; - } - } - $form->appendChild( $report_select ); - $form->appendChild( $repo->render_hidden_field( "screen", $self->{screenid} ) ); - #render possible search forms - foreach my $formid (keys %search_forms) - { - my $fields_tag = $search_forms{$formid}->findnodes('tr')->size > 0 ? "table" : "div"; - my $fields_wrapper = $repo->make_element( $fields_tag, class=>"ep_search_fields", id=>$formid, style=>"display: none" ); - $form->appendChild( $fields_wrapper ); - $fields_wrapper->appendChild( $search_forms{$formid} ) + my $template = $repo->make_element( "template", id => $formid ); + my $table = $repo->make_element( "div", class=>"ep_table ep_search_fields", id=>"form_$formid" ); + $table->appendChild( $frag ); + $template->appendChild( $table ); + $custom->appendChild( $template ); + + # keep a record of this search form to save us from rendering it again + push @search_forms, $formid; + } } - $form->appendChild( $self->render_controls ); - $custom->appendChild( $form ); + # label for form select drop down + my $report_label = $repo->make_element( "label", id=>"report_select_label" ); + $report_label->appendChild( $repo->html_phrase( "report_select_label" ) ); + $form->appendChild( $report_label ); + $form->appendChild( $report_select ); + + $form->appendChild( $repo->render_hidden_field( "screen", $self->{screenid} ) ); + $form->appendChild( $repo->make_element( "div", id=>"form_container" ) ); + + $form->appendChild( $self->render_controls ); + + $custom->appendChild( $form ); #javascript for changing forms based on report selection $custom->appendChild( $repo->make_javascript( 'initReportForm();' ) ); @@ -678,44 +699,62 @@ sub render_splash_page sub render_search_fields { - my( $self, $search, $formid ) = @_; + my( $self, $search, $formid ) = @_; my $exp = $self->{session}->param( "exp" ); my $sconf = $self->{session}->param( "sconf" ); - if( defined $exp && defined $sconf && $sconf eq $formid ) + if( defined $exp && defined $sconf && $sconf eq $formid ) { - $search->from_string( $exp ); + $search->from_string( $exp ); } - my $frag = $self->{session}->make_doc_fragment; - foreach my $sf ( $search->get_non_filter_searchfields ) + my $frag = $self->{session}->make_doc_fragment; + foreach my $sf ( $search->get_non_filter_searchfields ) + { + my $label; + my $field; + if ( $sf->{"field"}->get_type() eq "namedset" ) { - $frag->appendChild( - $self->{session}->render_row_with_help( - help_prefix => $sf->get_form_prefix."_help", - help => $sf->render_help, - label => $sf->render_name, - field => $sf->render, - no_toggle => ( $sf->{show_help} eq "always" ), - no_help => ( $sf->{show_help} eq "never" ), - ) ); + # we want a legend and a label + $label = $self->{session}->make_element( "span", id=>$sf->get_form_prefix."_label" ); + $label->appendChild( $sf->render_name ); + + my $legend = EPrints::Utils::tree_to_utf8( $sf->render_name ); + $field = $sf->render( legend => $legend ); + } + else { + $label = $self->{session}->make_element( "span", id=>$sf->get_form_prefix."_label" ); + $label->appendChild( $sf->render_name ); + $field = $sf->render(); } - return $frag; + $frag->appendChild( + $self->{session}->render_row_with_help( + help_prefix => $sf->get_form_prefix."_help", + help => $sf->render_help, + label => $label, + field => $field, + no_toggle => ( $sf->{show_help} eq "always" ), + no_help => ( $sf->{show_help} eq "never" ), + ) ); + } + + return $frag; } sub render_controls { my( $self, $with_js ) = @_; - my $div = $self->{session}->make_element( - "div" , - class => "ep_search_buttons" ); - $div->appendChild( $self->{session}->render_action_buttons( - _order => [ "search" ], - #newsearch => $self->{session}->phrase( "lib/searchexpression:action_reset" ), - search => $self->{session}->phrase( "lib/searchexpression:action_search" ) ) - ); + my $div = $self->{session}->make_element( + "div" , + class => "ep_search_buttons" ); + + $div->appendChild( $self->{session}->render_action_buttons( + _order => [ "search" ], + #newsearch => $self->{session}->phrase( "lib/searchexpression:action_reset" ), + search => $self->{session}->phrase( "lib/searchexpression:action_search" ) ) + ); my $xml = $self->{session}->xml; @@ -724,12 +763,12 @@ sub render_controls my $clear_form = $div->appendChild( $self->render_clearform( $xml ) ); } - my $clear_btn = $div->appendChild( $xml->create_element( "button", - type => "button", - onclick => "clearForm();", - class => "ep_form_action_button clear_button", - ) ); - $clear_btn->appendChild( $xml->create_text_node( $self->{session}->html_phrase( "lib/searchexpression:action_reset" ) ) ); + my $clear_btn = $div->appendChild( $xml->create_element( "button", + type => "button", + onclick => "clearForm();", + class => "ep_form_action_button clear_button", + ) ); + $clear_btn->appendChild( $xml->create_text_node( $self->{session}->phrase( "lib/searchexpression:action_reset" ) ) ); return $div; } @@ -863,6 +902,10 @@ sub render_export_bar $form->appendChild( $repo->render_hidden_field( "group", $self->{processor}->{group_exp} ) ); } + my $export_label = $repo->make_element( "label", id=>"export_select_label" ); + $export_label->appendChild( $repo->html_phrase( "export_select_label" ) ); + $form->appendChild( $export_label ); + if( !defined( $repo->config( $self->{export_conf}, "exportfields" ) ) ) { #no custom export fields defined, use export plugins designed for this report @@ -870,6 +913,7 @@ sub render_export_bar name => 'export', values => [map { $_->get_subtype } @plugins], labels => {map { $_->get_subtype => $_->get_name } @plugins}, + 'aria-labelledby' => "export_select_label", ) ); } else @@ -880,6 +924,7 @@ sub render_export_bar name => 'export', values => [map { $_->get_subtype } @plugins], labels => {map { $_->get_subtype => $_->get_name } @plugins}, + 'aria-labelledby' => "export_select_label", ) ); #create labels and panels for tabbed interfaced @@ -892,7 +937,7 @@ sub render_export_bar onclick => "toggleCheckboxes();", class => "ep_form_action_button select_button", ) ); - $select_btn->appendChild( $xml->create_text_node( $repo->html_phrase( "report_select" ) ) ); + $select_btn->appendChild( $xml->create_text_node( $repo->phrase( "report_select" ) ) ); #allow user to choose which fields they want to export my $export_options = $repo->make_element( "div" ); @@ -932,7 +977,7 @@ sub render_export_bar if( $count ) #only add options if we have any fields to show { my $div = $repo->make_element( "div", class=>"report_export_options" ); - $div->appendChild( my $h = $repo->make_element( "h4" ) ); + $div->appendChild( my $h = $repo->make_element( "div", class=>"custom_export_header" ) ); $h->appendChild( $repo->html_phrase( "exportfields:$key" ) ); $div->appendChild( $ul ); $export_options->appendChild( $div ); @@ -959,7 +1004,7 @@ sub render_export_bar $options{show_icon_url} = "$imagesurl/multi_down.png"; $options{hide_icon_url} = "$imagesurl/multi_up.png"; - my $box = $repo->make_element( "div", style=>"text-align: left" ); + my $box = $repo->make_element( "div", style=>"text-align: left", class=>$self->{report} ); $box->appendChild( EPrints::Box::render( %options ) ); $chunk->appendChild( $box ); @@ -1171,10 +1216,15 @@ sub _export_field_checkbox { if( ( grep { $fieldname eq $_ } @{$repo->config( $self->{export_conf}, "exportfield_defaults" )} ) || ( scalar( @{$repo->config( $self->{export_conf}, "exportfield_defaults" )} ) == 0 ) ) { - #only check defaults or check everything if defaults not defined + # check defaults as specified $checkbox->setAttribute( "checked", "yes" ); } } + else # defaults not defined + { + $checkbox->setAttribute( "checked", "yes" ); + } + my $label = $repo->make_element( "label", for => $fieldname ); $label->appendChild( $fieldlabel ); diff --git a/lib/static/javascript/auto/reports.js b/lib/static/javascript/auto/reports.js index 20b3633..d82e44c 100644 --- a/lib/static/javascript/auto/reports.js +++ b/lib/static/javascript/auto/reports.js @@ -27,167 +27,376 @@ var initReportForm = function(){ var onFormSelect = function(){ - //get form id - var formid = this.options[this.selectedIndex].getAttribute('form'); - - //hide other forms - $$('.ep_search_fields').each(function (elem) - { - //hide the form - $(elem).hide(); - $(elem).removeClassName("selected_form"); - $(elem).select('input').each(function (input) - { - $(input).setAttribute("disabled", "disabled"); - }); - $(elem).select('select').each(function (select) - { - $(select).setAttribute("disabled", "disabled"); - }); - }); - - //show the form we want - $(formid).show(); - $(formid).addClassName("selected_form"); - - //enable this form's input elements - $(formid).select('input').each(function (input) - { - $(input).removeAttribute("disabled"); - }); - //enable this form's select elements - $(formid).select('select').each(function (select) - { - $(select).removeAttribute("disabled"); - }); - + //get form id + var formid = this.options[this.selectedIndex].getAttribute('form'); + const container = document.getElementById("form_container"); + container.innerHTML = ''; + const clone = $(formid).content.cloneNode(true); + container.appendChild(clone); }; // Used by the Screen::Report::render method var EPrints_Screen_Report_Loader = Class.create({ - has_problems: 0, - count: 0, - runs: 0, - progress: null, - ids: Array(), - step: null, - minStep: 20, // If `step` is set to `null` then this is the minimum `step` value - prefix: '', - onProblems: function() {}, - onFinish: function() {}, - url: "", - parameters: "", - container: null, - show_compliance: 1, - - // to show a pretty progress bar (% compliance): - total_dataobjs: 0, - total_noncompliant: 0, - - - initialize: function(opts) { - if( opts.ids ) - this.ids = opts.ids; - if( opts.step ) - this.step = opts.step; - if( opts.minStep ) - this.minStep = opts.minStep; - if( opts.prefix ) - this.prefix = opts.prefix; - if( opts.onFinish ) - this.onFinish = opts.onFinish; - if( opts.onProblems ) - this.onProblems = opts.onProblems; - if( opts.url ) - { - this.url = opts.url; - } - if( opts.parameters ) - this.parameters = opts.parameters; - if( opts.container_id ) - this.container = $( opts.container_id ); // should fail if container doesn't exist... - if( opts.hasOwnProperty('show_compliance') ) - { - this.show_compliance = opts.show_compliance; - } - if( opts.labels ) - { - this.labels = opts.labels; - } - }, + has_problems: 0, + count: 0, + runs: 0, + progress: null, + ids: Array(), + seen_ids: {}, + step: null, + minStep: 20, + batch: 0, + grouped: false, + prefix: '', + onProblems: function() {}, + onFinish: function() {}, + url: "", + parameters: "", + container: null, + show_compliance: 1, + + // to show a pretty progress bar (% compliance): + total_dataobjs: 0, + total_noncompliant: 0, + + + initialize: function(opts) { + if( opts.ids ) + this.ids = opts.ids; + if( opts.step ) + this.step = opts.step; + if( opts.minStep ) + this.minStep = opts.minStep; + if( opts.prefix ) + this.prefix = opts.prefix; + if( opts.onFinish ) + this.onFinish = opts.onFinish; + if( opts.onProblems ) + this.onProblems = opts.onProblems; + if( opts.url ) + { + this.url = opts.url; + } + if( opts.parameters ) + this.parameters = opts.parameters; + if( opts.container_id ) + this.container = $( opts.container_id ); // should fail if container doesn't exist... + if( opts.hasOwnProperty('show_compliance') ) + { + this.show_compliance = opts.show_compliance; + } + if( opts.labels ) + { + this.labels = opts.labels; + } + }, + + // break down the requests into batches as defined by the step size + // don't move on to the next batch until we've handled the previous one + runBatch: function() { + + var dataobjs = {}; + + var i = this.batch * this.step; + + // arguments for Ajax query AND creates the HTML placeholders
's (that will receive the content of the Ajax query...) + var args = '&ajax='+this.prefix + + // build up our request for this step's results + for(var j = 0; j < this.step && i+j < this.ids.length; j++) + { + args += '&' + this.prefix + '=' + this.ids[i+j]; + var id = this.prefix + '_' + this.ids[i+j]; + var target_el = $( id ); + if( target_el != null ) + { + //store a record of this in seen_ids to ensure each placeholder has a unique id + if( !(id in this.seen_ids) ) + { + this.seen_ids[id] = 1; + } + else + { + this.seen_ids[id] = this.seen_ids[id] + 1; + } + id = id + "_" + this.seen_ids[id]; + } + + // set up an element for this result + this.container.insert( new Element( 'div', { 'class': 'ep_report_row', 'id': id, 'position': i+j } ), { 'position': 'after' } ); + } + + new Ajax.Request( this.url, { + method: 'get', + parameters: this.parameters + args, + onSuccess: (function(transport) { + + // we got our report data back from the plugin + var json = transport.responseText.evalJSON(); + var data = json.data; + if( data == null ) + { + data = new Array(); + } + + for( var n = 0; n < data.length; n++ ) + { + var entry = data[n]; + + // no entry - awkward + if( entry == null ) + { + continue; + } + + // no dataobj id - also awkward + var dataobjid = entry.dataobjid; + if( dataobjid == null ) + { + continue; + } + + // we have a dataobj, let's record it... + if( !(dataobjid in dataobjs) ) + { + this.count++; + dataobjs[dataobjid] = entry; + } + } - execute: function() { - // progress-bar + //add the eprint summaries for this step + var added_ids = {}; + + //for( var c = this.batch * this.step; c < (this.batch * this.step) + this.step; c++ ) + for( var c = 0; c < this.step && i+c < this.ids.length; c++ ) + { + var dataobjid = this.ids[i+c]; + var entry = dataobjs[dataobjid]; + + //store that we have added this objectid + if( !(dataobjid in added_ids) ) + { + added_ids[dataobjid] = 0; + } + else + { + added_ids[dataobjid] = added_ids[dataobjid] + 1; + } + this.total_dataobjs++; + + var summary = entry.summary; + + var target_id = this.prefix + '_' + dataobjid; + if( added_ids[dataobjid] > 0 ) + { + target_id = target_id + '_' + added_ids[dataobjid]; + } + var target_el = $( target_id ); + + if( target_el != null && summary != null ) + { + var summary_el = target_el.appendChild( new Element( 'div', { 'class': 'ep_report_row_summary' } ) ); + summary_el.update( summary ); + + //total up non compliant records + if( entry.is_compliant == null && entry.problems && entry.problems.length ) + { + this.total_noncompliant++; + } + + //add support for compliant items to include bullet points too + if( entry.bullets && entry.bullets.length ) + { + var bullets_el = target_el.appendChild( new Element( 'ul', { 'class': 'ep_report_row_bullets' } ) ); + + for( var b = 0; b < entry.bullets.length; b++ ) + { + var li = bullets_el.appendChild( new Element( 'li' )); + li.update( entry.bullets[b] ); + } + } + + if( entry.problems && entry.problems.length ) + { + var problems_el = target_el.appendChild( new Element( 'ul', { 'class': 'ep_report_row_problems' } ) ); + + for( var p = 0; p < entry.problems.length; p++ ) + { + var li = problems_el.appendChild( new Element( 'li' )); + li.update( entry.problems[p] ); + } + } + + //display state + var re = new RegExp("^#(?:[0-9a-fA-F]{3}){1,2}$"); + if( entry.state && re.test(entry.state) ) + { + target_el.style.borderLeftWidth = '7px'; + target_el.style.borderLeftStyle = 'solid'; + target_el.style.borderLeftColor = entry.state; + } + else //no state provided, so derive one from existence of problems + { + if( entry.problems && entry.problems.length ) + { + target_el.addClassName( 'ep_report_row_problems' ); + } + else + { + target_el.addClassName( 'ep_report_row_ok' ); + } + + if( !this.show_compliance ) + { + target_el.addClassName( 'ep_report_row_no_compliance' ); + } + } + target_el.show(); + + var grouping = entry.grouping; + if( grouping != null ) + { + if( current_grouping == null || current_grouping != grouping) + { + current_grouping = grouping; + var grouping_container = new Element( 'div', { 'class': 'ep_report_grouping' } ); + target_el.insert( { 'before' : grouping_container } ); + grouping_container.update( current_grouping ); + } + } + } + } + + // we've retrieved all the records - this is the final step so tidy things up + if( this.count == this.no_items ) + { + $( this.prefix + '_progress_bar' ).remove(); + if( this.has_problems ) + { + this.onProblems(this); + } + this.onFinish(this); + + //add the group headings + if(this.grouped) + { + var position = 0; + for( var m = 0; m < this.grouped_ids.length; m++ ) + { + var target_el = document.querySelectorAll('[position="' + position + '"]')[0]; + position = position + this.grouped_ids[m].list.length; + var grouping_container = new Element( 'div', { 'class': 'ep_report_grouping' } ); + target_el.insert( { 'before' : grouping_container } ); + grouping_container.update( this.grouped_ids[m].label ); + } + } + + this.container.insertBefore( new Element( 'div', { 'class': 'ep_report_compliance_container', 'id': this.prefix + "_compliance_container" } ), this.container.firstChild ); + + //set up text container + $( this.prefix + "_compliance_container" ).appendChild( new Element( 'div', { 'class': 'ep_report_compliance_text', 'id': this.prefix + "_compliance_text", } )); + + //set up outputs label + var outputs; + if( this.labels ) + { + outputs = this.labels.outputs; + } + else + { + outputs = "output"; + if( this.total_dataobjs > 1 ) + { + outputs = outputs + "s"; + } + } + + if( this.show_compliance ) + { + var ref_width = 200; + var compliance = ( this.total_dataobjs - this.total_noncompliant ) / this.total_dataobjs; + + $( this.prefix + "_compliance_container" ).appendChild( new Element( 'div', { 'class': 'ep_report_compliance_wrapper', 'id': this.prefix + "_compliance", 'style': 'width: '+ref_width + 'px' } ) ); + + var compliance_width = Math.floor( 200 * compliance ); + + $( this.prefix + "_compliance" ).appendChild( new Element( 'div', { 'class': 'ep_report_compliance', 'style': 'width:'+compliance_width + 'px' } ) ); + + $( this.prefix + "_compliance_text" ).update( this.total_dataobjs + " " + outputs + " - " + Math.floor( compliance * 100 ) + "% compliance"); + } + else + { + $( this.prefix + "_compliance_text" ).update( this.total_dataobjs + " " + outputs ); + } - this.container.insert( new Element( 'div', { 'class': 'ep_report_progress_bar', 'id': this.prefix + "_progress_bar" } ) ); - this.current_grouping = null; // might not be set in the returned value but that's allowed/OK - this.dataobjs = {}; - var grouped = false; - var seen_ids = {}; - this.no_items = this.ids.length; - this.retrieved = []; + } + else + { + // update progress bar + var width = 200; + $( this.prefix + '_progress_bar' ).style.backgroundPosition = Math.round(-width + width * this.count / this.ids.length) + "px 0px"; + + // and run another batch + this.batch++; + this.runBatch(); + } - // Unless `step` is set this will automatically calculate it depending + // nothing to show... + if( this.runs == 0 && this.count == 0 ) + { + var pNode = $( this.prefix + '_progress_bar' ).parentNode; + $(this.prefix + '_progress_bar').remove(); + var span = new Element( 'span', { 'class': 'ep_ref_report_empty' } ); + span.update( 'Report empty' ); + pNode.insert( span ); + } + this.runs++; + }).bind(this) + }); + }, + execute: function() { + // progress-bar + this.container.insert( new Element( 'div', { 'class': 'ep_report_progress_bar', 'id': this.prefix + "_progress_bar" } ) ); + + var current_grouping = null; // might not be set in the returned value but that's allowed/OK + this.no_items = this.ids.length; + this.retrieved = []; + + // Unless `step` is set this will automatically calculate it depending // on the number of items in the list. // This allows the steps to scale with larger queries (aiming for 100 // AJAX requests) so that it doesn't cause Server Errors. if (this.step === null) { - this.step = Math.max(Math.round(this.no_items / 100), this.minStep); + this.step = Math.max(Math.round(this.no_items / 100), this.minStep); } - if( !isInteger(this.ids[0]) ) //ids have been grouped - { - grouped = true; - this.grouped_ids = this.ids; - this.ids = []; - for( var i = 0; i < this.grouped_ids.length; i++ ) - { - this.ids = this.ids.concat(this.grouped_ids[i].list); - } - //the grouping may have created duplicate records (i.e. a record can appear in more than one group) - it's handy to have an array of all the unique records - this.unique = this.ids.filter(function(item, i, ar){ return ar.indexOf(item) === i; }); - this.no_items = this.unique.length; - } - for(var i = 0; i < this.ids.length; i+=this.step) - { - // arguments for Ajax query AND creates the HTML placeholders
's (that will receive the content of the Ajax query...) - var args = '&ajax='+this.prefix; - for(var j = 0; j < this.step && i+j < this.ids.length; j++) - { - args += '&' + this.prefix + '=' + this.ids[i+j]; - var id = this.prefix + '_' + this.ids[i+j]; - var target_el = $( id ); - if( target_el != null ) - { - //store a record of this in seen_ids to ensure each placeholder has a unique id - if( !(id in seen_ids) ) - { - seen_ids[id] = 1; - } - else - { - seen_ids[id] = seen_ids[id] + 1; - } - id = id + "_" + seen_ids[id]; - } - - this.container.insert( new Element( 'div', { 'class': 'ep_report_row', 'id': id, 'position': i+j } ), { 'position': 'after' } ); - } - - makeRequest(this, args, grouped); - } - if( this.ids == null || this.ids.length == 0 ) - { - var pNode = $(this.prefix + '_progress_bar').parentNode; - $(this.prefix + '_progress_bar').hide(); - var span = new Element( 'span', { 'class': 'ep_ref_report_empty' } ); - span.update( 'Report empty' ); - pNode.insert( span ); - } - } + if( !isInteger(this.ids[0]) ) //ids have been grouped + { + this.grouped = true; + this.grouped_ids = this.ids; + this.ids = []; + for( var i = 0; i < this.grouped_ids.length; i++ ) + { + this.ids = this.ids.concat(this.grouped_ids[i].list); + } + //the grouping may have created duplicate records (i.e. a record can appear in more than one group) - it's handy to have an array of all the unique records + this.unique = this.ids.filter(function(item, i, ar){ return ar.indexOf(item) === i; }); + this.no_items = this.unique.length; + } + + if( this.ids == null || this.ids.length == 0 ) + { + var pNode = $(this.prefix + '_progress_bar').parentNode; + $(this.prefix + '_progress_bar').hide(); + var span = new Element( 'span', { 'class': 'ep_ref_report_empty' } ); + span.update( 'Report empty' ); + pNode.insert( span ); + } + this.runBatch(); + } }); function makeRequest(loader, args, grouped) { @@ -418,14 +627,14 @@ function makeRequest(loader, args, grouped) { function group_report(group) { - document.group_report.group.value = group; - document.group_report.submit(); + document.group_report.group.value = group; + document.group_report.submit(); } function sort_report(sort) { - document.sort_report.sort.value = sort; - document.sort_report.submit(); + document.sort_report.sort.value = sort; + document.sort_report.submit(); } function isInteger(num) { diff --git a/lib/static/style/auto/reports.css b/lib/static/style/auto/reports.css index bf92297..ac53949 100644 --- a/lib/static/style/auto/reports.css +++ b/lib/static/style/auto/reports.css @@ -114,6 +114,12 @@ div#ep_report_export_content_inner .report_export_options ul margin-left: 2px; } +#report_select_label, #export_select_label +{ + font-weight: 700; + margin-right: 5px; +} + /* HTML Reports */ a.html_report_print{ text-decoration: none; diff --git a/reports.epm b/reports.epm index 391a08f..f2bccfa 100644 --- a/reports.epm +++ b/reports.epm @@ -1,11 +1,12 @@ - + reports - https://epm.eprints-hosting.org/id/epm/reports + http://localhost:8080/id/epm/reports + document epm/reports/cfg/cfg.d/z_example_reports.pl.off text/plain 73e01974ab33e9a4d7972141c820c7a2 @@ -40,11 +41,12 @@ cGxlX2ZpZWxkcyB9Owo= + document epm/reports/cfg/cfg.d/z_reports.pl text/plain - 48c622ad150bea255ba6fbee7e37083b + e0c09c35dc9b17fa48a00ad0555653fc MD5 - 2869 + 2905 IwojIEVQcmludHMgU2VydmljZXMgLSBHZW5lcmljIFJlcG9ydGluZyBTeXN0ZW0KIwojIFZlcnNp b246IDMuMAojCgoKJGMtPntwbHVnaW5zfXsiU2NyZWVuOjpSZXBvcnQifXtwYXJhbXN9e2Rpc2Fi bGV9ID0gMDsKCiRjLT57cGx1Z2luc317IkV4cG9ydDo6UmVwb3J0In17cGFyYW1zfXtkaXNhYmxl @@ -55,50 +57,51 @@ e2Rpc2FibGV9ID0gMDsKCiRjLT57cGx1Z2luc317IlNjcmVlbjo6UmVwb3J0OjpFUHJpbnQifXtw YXJhbXN9e2Rpc2FibGV9ID0gMDsKJGMtPntwbHVnaW5zfXsiU2NyZWVuOjpSZXBvcnQ6OkVQcmlu dCJ9e3BhcmFtc317Y3VzdG9tfSA9IDE7CiRjLT57cGx1Z2luc317IlNjcmVlbjo6UmVwb3J0OjpV c2VyIn17cGFyYW1zfXtkaXNhYmxlfSA9IDA7CiRjLT57cGx1Z2luc317IlNjcmVlbjo6UmVwb3J0 -OjpVc2VyIn17cGFyYW1zfXtjdXN0b219ID0gMTsKCiNzZXQgY29uZmlnIGZvciBkZWZhdWx0IGVw -cmludCByZXBvcnQKJGMtPntzZWFyY2h9LT57ZXByaW50X3JlcG9ydH0gPSAkYy0+e3NlYXJjaH0t -PnthZHZhbmNlZH07ICN1c2UgdGhlIGFkdmFuY2VkIHNlYXJjaCBmb3JtIGFzIHRoZSBkZWZhdWx0 -IGVwcmludCByZXBvcnQgc2VhcmNoCgojZ3JvdXAgYnkgb3B0aW9ucwokYy0+e2VwcmludF9yZXBv -cnR9LT57Z3JvdXBmaWVsZHN9ID0gWyBxdygKCWRpdmlzaW9ucwoJc3ViamVjdHMKICAgICAgICB0 -eXBlCglkYXRlO3Jlcz15ZWFyO3JldmVyc2Vfb3JkZXI9MQopXTsKCiNzb3J0IG9wdGlvbnMgZm9y -IHNvcnRpbmcgd2l0aGluIGVhY2ggZ3JvdXAKJGMtPntlcHJpbnRfcmVwb3J0fS0+e3NvcnRmaWVs -ZHN9ID0gewogICAgICAgICJieW5hbWUiID0+ICJjcmVhdG9yc19uYW1lLy1kYXRlL3RpdGxlIiwK -ICAgICAgICAiYnl5ZWFyIiA9PiAiLWRhdGUvY3JlYXRvcnNfbmFtZS90aXRsZSIsCiAgICAgICAg -ImJ5dGl0bGUiID0+ICJ0aXRsZS9jcmVhdG9yc19uYW1lLy1kYXRlIiwKICAgICAgICAiYnlkaXZp -c2lvbiIgPT4gImRpdmlzaW9ucy9jcmVhdG9yc19uYW1lLy1kYXRlIiwKfTsKCiNleHBvcnQgZmll -bGQgb3B0aW9ucwokYy0+e2VwcmludF9yZXBvcnR9LT57ZXhwb3J0ZmllbGRzfSA9IHsKICAgICAg -ICBlcHJpbnRfcmVwb3J0X2NvcmUgPT4gWyBxdygKCQllcHJpbnRpZAogICAgICAgICAgICAgICAg -dGl0bGUKICAgICAgICAgICAgICAgIGNyZWF0b3JzX25hbWUKICAgICAgICAgICAgICAgIGFic3Ry -YWN0CiAgICAgICAgICAgICAgICBkYXRlCiAgICAgICAgICAgICAgICBrZXl3b3JkcwogICAgICAg -ICAgICAgICAgZGl2aXNpb25zCiAgICAgICAgICAgICAgICBzdWJqZWN0cwogICAgICAgICAgICAg -ICAgdHlwZQogICAgICAgICAgICAgICAgZWRpdG9yc19uYW1lCiAgICAgICAgICAgICAgICBpc3B1 -Ymxpc2hlZAogICAgICAgICAgICAgICAgcmVmZXJlZWQKICAgICAgICAgICAgICAgIHB1YmxpY2F0 -aW9uCiAgICAgICAgICAgICAgICBkb2N1bWVudHMuZm9ybWF0CiAgICAgICAgICAgICAgICBkYXRl -c3RhbXAKICAgICAgICApXSwKfTsKJGMtPntlcHJpbnRfcmVwb3J0fS0+e2V4cG9ydGZpZWxkX2Rl -ZmF1bHRzfSA9IFsgcXcoCgllcHJpbnRpZAoJdGl0bGUKICAgICAgICBjcmVhdG9yc19uYW1lCiAg -ICAgICAgYWJzdHJhY3QKICAgICAgICBkYXRlCiAgICAgICAga2V5d29yZHMKICAgICAgICBkaXZp -c2lvbnMKICAgICAgICBzdWJqZWN0cwogICAgICAgIHR5cGUKICAgICAgICBlZGl0b3JzX25hbWUK -ICAgICAgICBpc3B1Ymxpc2hlZAogICAgICAgIHJlZmVyZWVkCiAgICAgICAgcHVibGljYXRpb24K -CWRvY3VtZW50cy5mb3JtYXQKCWRhdGVzdGFtcAopXTsKCiNzZXQgb3JkZXIgb2YgZXhwb3J0IHBs -dWdpbnMKJGMtPntlcHJpbnRfcmVwb3J0fS0+e2V4cG9ydF9wbHVnaW5zfSA9IFsgcXcoIEV4cG9y -dDo6UmVwb3J0OjpDU1YgRXhwb3J0OjpSZXBvcnQ6OkhUTUwgRXhwb3J0OjpSZXBvcnQ6OkpTT04g -KV07Cgojc2V0IGNvbmZpZyBmb3IgZGVmYXVsdCB1c2VyIHJlcG9ydAokYy0+e2RhdGFzZXRzfS0+ -e3VzZXJ9LT57c2VhcmNofS0+e3VzZXJfcmVwb3J0fSA9ICRjLT57c2VhcmNofS0+e3VzZXJ9OyAj -dXNlIHRoZSBkZWZhdWx0IHVzZXIgc2VhcmNoIGZvcm0KCiNzb3J0IG9wdGlvbnMgZm9yIHNvcnRp -bmcgd2l0aGluIGVhY2ggZ3JvdXAKJGMtPnt1c2VyX3JlcG9ydH0tPntzb3J0ZmllbGRzfSA9IHsK -ICAgICAgICAiYnluYW1lIiA9PiAibmFtZSIsCn07CgojZXhwb3J0IGZpZWxkIG9wdGlvbnMKJGMt -Pnt1c2VyX3JlcG9ydH0tPntleHBvcnRmaWVsZHN9ID0gewogICAgICAgIHVzZXJfcmVwb3J0X2Nv -cmUgPT4gWyBxdygKICAgICAgICAJbmFtZQoJCXVzZXJuYW1lCgkJdXNlcmlkCgkJZGVwdAoJCW9y -ZwoJCWFkZHJlc3MKCQl1c2VydHlwZQoJCWVtYWlsCgkpXSwKfTsKCiRjLT57dXNlcl9yZXBvcnR9 -LT57ZXhwb3J0ZmllbGRfZGVmYXVsdHN9ID0gWyBxdygKICAgICAgICBuYW1lCgl1c2VybmFtZQoJ -dXNlcmlkCglkZXB0CglvcmcKCWFkZHJlc3MKCXVzZXJ0eXBlCgllbWFpbAopXTsKCiNzZXQgb3Jk -ZXIgb2YgZXhwb3J0IHBsdWdpbnMKJGMtPnt1c2VyX3JlcG9ydH0tPntleHBvcnRfcGx1Z2luc30g -PSBbIHF3KCBFeHBvcnQ6OlJlcG9ydDo6Q1NWIEV4cG9ydDo6UmVwb3J0OjpIVE1MIEV4cG9ydDo6 -UmVwb3J0OjpKU09OICldOwoKcHVzaCBAeyRjLT57dXNlcl9yb2xlc30tPnthZG1pbn19LCBxd3sK -ICAgICAgICArcmVwb3J0Cn07Cg== +OjpVc2VyIn17cGFyYW1zfXtjdXN0b219ID0gMTsKCiRjLT57cmVwb3J0c30tPntjc3ZfdXRmOF9i +b219ID0gMTsKCiNzZXQgY29uZmlnIGZvciBkZWZhdWx0IGVwcmludCByZXBvcnQKJGMtPntzZWFy +Y2h9LT57ZXByaW50X3JlcG9ydH0gPSAkYy0+e3NlYXJjaH0tPnthZHZhbmNlZH07ICN1c2UgdGhl +IGFkdmFuY2VkIHNlYXJjaCBmb3JtIGFzIHRoZSBkZWZhdWx0IGVwcmludCByZXBvcnQgc2VhcmNo +CgojZ3JvdXAgYnkgb3B0aW9ucwokYy0+e2VwcmludF9yZXBvcnR9LT57Z3JvdXBmaWVsZHN9ID0g +WyBxdygKCWRpdmlzaW9ucwoJc3ViamVjdHMKICAgICAgICB0eXBlCglkYXRlO3Jlcz15ZWFyO3Jl +dmVyc2Vfb3JkZXI9MQopXTsKCiNzb3J0IG9wdGlvbnMgZm9yIHNvcnRpbmcgd2l0aGluIGVhY2gg +Z3JvdXAKJGMtPntlcHJpbnRfcmVwb3J0fS0+e3NvcnRmaWVsZHN9ID0gewogICAgICAgICJieW5h +bWUiID0+ICJjcmVhdG9yc19uYW1lLy1kYXRlL3RpdGxlIiwKICAgICAgICAiYnl5ZWFyIiA9PiAi +LWRhdGUvY3JlYXRvcnNfbmFtZS90aXRsZSIsCiAgICAgICAgImJ5dGl0bGUiID0+ICJ0aXRsZS9j +cmVhdG9yc19uYW1lLy1kYXRlIiwKICAgICAgICAiYnlkaXZpc2lvbiIgPT4gImRpdmlzaW9ucy9j +cmVhdG9yc19uYW1lLy1kYXRlIiwKfTsKCiNleHBvcnQgZmllbGQgb3B0aW9ucwokYy0+e2Vwcmlu +dF9yZXBvcnR9LT57ZXhwb3J0ZmllbGRzfSA9IHsKICAgICAgICBlcHJpbnRfcmVwb3J0X2NvcmUg +PT4gWyBxdygKCQllcHJpbnRpZAogICAgICAgICAgICAgICAgdGl0bGUKICAgICAgICAgICAgICAg +IGNyZWF0b3JzX25hbWUKICAgICAgICAgICAgICAgIGFic3RyYWN0CiAgICAgICAgICAgICAgICBk +YXRlCiAgICAgICAgICAgICAgICBrZXl3b3JkcwogICAgICAgICAgICAgICAgZGl2aXNpb25zCiAg +ICAgICAgICAgICAgICBzdWJqZWN0cwogICAgICAgICAgICAgICAgdHlwZQogICAgICAgICAgICAg +ICAgZWRpdG9yc19uYW1lCiAgICAgICAgICAgICAgICBpc3B1Ymxpc2hlZAogICAgICAgICAgICAg +ICAgcmVmZXJlZWQKICAgICAgICAgICAgICAgIHB1YmxpY2F0aW9uCiAgICAgICAgICAgICAgICBk +b2N1bWVudHMuZm9ybWF0CiAgICAgICAgICAgICAgICBkYXRlc3RhbXAKICAgICAgICApXSwKfTsK +JGMtPntlcHJpbnRfcmVwb3J0fS0+e2V4cG9ydGZpZWxkX2RlZmF1bHRzfSA9IFsgcXcoCgllcHJp +bnRpZAoJdGl0bGUKICAgICAgICBjcmVhdG9yc19uYW1lCiAgICAgICAgYWJzdHJhY3QKICAgICAg +ICBkYXRlCiAgICAgICAga2V5d29yZHMKICAgICAgICBkaXZpc2lvbnMKICAgICAgICBzdWJqZWN0 +cwogICAgICAgIHR5cGUKICAgICAgICBlZGl0b3JzX25hbWUKICAgICAgICBpc3B1Ymxpc2hlZAog +ICAgICAgIHJlZmVyZWVkCiAgICAgICAgcHVibGljYXRpb24KCWRvY3VtZW50cy5mb3JtYXQKCWRh +dGVzdGFtcAopXTsKCiNzZXQgb3JkZXIgb2YgZXhwb3J0IHBsdWdpbnMKJGMtPntlcHJpbnRfcmVw +b3J0fS0+e2V4cG9ydF9wbHVnaW5zfSA9IFsgcXcoIEV4cG9ydDo6UmVwb3J0OjpDU1YgRXhwb3J0 +OjpSZXBvcnQ6OkhUTUwgRXhwb3J0OjpSZXBvcnQ6OkpTT04gKV07Cgojc2V0IGNvbmZpZyBmb3Ig +ZGVmYXVsdCB1c2VyIHJlcG9ydAokYy0+e2RhdGFzZXRzfS0+e3VzZXJ9LT57c2VhcmNofS0+e3Vz +ZXJfcmVwb3J0fSA9ICRjLT57c2VhcmNofS0+e3VzZXJ9OyAjdXNlIHRoZSBkZWZhdWx0IHVzZXIg +c2VhcmNoIGZvcm0KCiNzb3J0IG9wdGlvbnMgZm9yIHNvcnRpbmcgd2l0aGluIGVhY2ggZ3JvdXAK +JGMtPnt1c2VyX3JlcG9ydH0tPntzb3J0ZmllbGRzfSA9IHsKICAgICAgICAiYnluYW1lIiA9PiAi +bmFtZSIsCn07CgojZXhwb3J0IGZpZWxkIG9wdGlvbnMKJGMtPnt1c2VyX3JlcG9ydH0tPntleHBv +cnRmaWVsZHN9ID0gewogICAgICAgIHVzZXJfcmVwb3J0X2NvcmUgPT4gWyBxdygKICAgICAgICAJ +bmFtZQoJCXVzZXJuYW1lCgkJdXNlcmlkCgkJZGVwdAoJCW9yZwoJCWFkZHJlc3MKCQl1c2VydHlw +ZQoJCWVtYWlsCgkpXSwKfTsKCiRjLT57dXNlcl9yZXBvcnR9LT57ZXhwb3J0ZmllbGRfZGVmYXVs +dHN9ID0gWyBxdygKICAgICAgICBuYW1lCgl1c2VybmFtZQoJdXNlcmlkCglkZXB0CglvcmcKCWFk +ZHJlc3MKCXVzZXJ0eXBlCgllbWFpbAopXTsKCiNzZXQgb3JkZXIgb2YgZXhwb3J0IHBsdWdpbnMK +JGMtPnt1c2VyX3JlcG9ydH0tPntleHBvcnRfcGx1Z2luc30gPSBbIHF3KCBFeHBvcnQ6OlJlcG9y +dDo6Q1NWIEV4cG9ydDo6UmVwb3J0OjpIVE1MIEV4cG9ydDo6UmVwb3J0OjpKU09OICldOwoKcHVz +aCBAeyRjLT57dXNlcl9yb2xlc30tPnthZG1pbn19LCBxd3sKICAgICAgICArcmVwb3J0Cn07Cg== + document epm/reports/cfg/cfg.d/z_search_reports.pl text/plain d85eb82057d42ddbf451390ce314d0ff @@ -132,250 +135,320 @@ ICAgIHNob3dfemVyb19yZXN1bHRzID0+IDEsCn07Cgo= + document lang/en/phrases/reports.xml - text/xml - 9c23d9b3d22356d0ff30793364082dbb + application/xml + ea18f8beec4a6fdaa4c1d0e588b38b55 MD5 - 2685 + 2765 PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0idXRmLTgiIHN0YW5kYWxvbmU9Im5vIj8+Cjwh RE9DVFlQRSBwaHJhc2VzIFNZU1RFTSAiZW50aXRpZXMuZHRkIj4KPGVwcDpwaHJhc2VzIHhtbG5z PSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiB4bWxuczplcHA9Imh0dHA6Ly9lcHJpbnRz Lm9yZy9lcDMvcGhyYXNlIiB4bWxuczplcGM9Imh0dHA6Ly9lcHJpbnRzLm9yZy9lcDMvY29udHJv bCI+Cgo8ZXBwOnBocmFzZSBpZD0ibGliL3JlcG9ydDpsb2FkaW5nIj5Mb2FkaW5nIHJlcG9ydC4u -LjwvZXBwOnBocmFzZT4KCjxlcHA6cGhyYXNlIGlkPSJQbHVnaW4vU2NyZWVuL1JlcG9ydDp0aXRs -ZSI+UmVwb3J0czwvZXBwOnBocmFzZT4KPGVwcDpwaHJhc2UgaWQ9IlBsdWdpbi9TY3JlZW4vUmVw -b3J0Om5vX3JlcG9ydHMiPk5vIGF2YWlsYWJsZSByZXBvcnRzPC9lcHA6cGhyYXNlPgoKPGVwcDpw -aHJhc2UgaWQ9InJlcG9ydHNfcHJlc2V0Ij5QcmVzZXQgUmVwb3J0czwvZXBwOnBocmFzZT4KPGVw -cDpwaHJhc2UgaWQ9InJlcG9ydHNfY3VzdG9tIj5DdXN0b20gUmVwb3J0czwvZXBwOnBocmFzZT4K -CjxlcHA6cGhyYXNlIGlkPSJSZXBvcnQ6c29ydF9saW5rcyI+PGRpdiBjbGFzcz0iZXBfdmlld19n -cm91cF9ieSI+U29ydCBieTogPGVwYzpwaW4gbmFtZT0ibGlua3MiIC8+PC9kaXY+PC9lcHA6cGhy -YXNlPgo8ZXBwOnBocmFzZSBpZD0iUmVwb3J0Omdyb3VwX2xpbmtzIj48ZGl2IGNsYXNzPSJlcF92 -aWV3X2dyb3VwX2J5Ij5Hcm91cCBieTogPGVwYzpwaW4gbmFtZT0ibGlua3MiIC8+PC9kaXY+PC9l -cHA6cGhyYXNlPgoKPGVwcDpwaHJhc2UgaWQ9InJlcG9ydDpub19ncm91cGluZyI+Tm8gR3JvdXBp -bmc8L2VwcDpwaHJhc2U+Cgo8ZXBwOnBocmFzZSBpZD0icmVwb3J0X3NlbGVjdCI+U2VsZWN0L0Rl -c2VsZWN0IEFsbDwvZXBwOnBocmFzZT4KCjxlcHA6cGhyYXNlIGlkPSJSZXBvcnQ6c2VhcmNoX2xp -bmtzIj48ZGl2IGNsYXNzPSJlcF92aWV3X2dyb3VwX2J5Ij48ZXBjOnBpbiBuYW1lPSJsaW5rcyIg -Lz48L2Rpdj48L2VwcDpwaHJhc2U+Cgo8IS0tIHRoZSBFeGFtcGxlIHJlcG9ydHMgLS0+CjxlcHA6 -cGhyYXNlIGlkPSJQbHVnaW4vU2NyZWVuL1JlcG9ydC9FeGFtcGxlOnRpdGxlIj5FeGFtcGxlPC9l -cHA6cGhyYXNlPgo8ZXBwOnBocmFzZSBpZD0iUGx1Z2luL1NjcmVlbi9SZXBvcnQvRXhhbXBsZS9B -cnRpY2xlczp0aXRsZSI+QXJ0aWNsZXM8L2VwcDpwaHJhc2U+CjxlcHA6cGhyYXNlIGlkPSJQbHVn -aW4vU2NyZWVuL1JlcG9ydC9FeGFtcGxlL0NvbmZlcmVuY2VJdGVtczp0aXRsZSI+Q29uZmVyZW5j -ZSBJdGVtczwvZXBwOnBocmFzZT4KCjxlcHA6cGhyYXNlIGlkPSJleHBvcnRfdGl0bGUiPkV4cG9y -dCBPcHRpb25zPC9lcHA6cGhyYXNlPgoKPCEtLSBIVE1MIEV4cG9ydCAtLT4KPGVwcDpwaHJhc2Ug -aWQ9InJlcG9ydF9odG1sX2V4cG9ydF90aXRsZSI+UmVwb3J0PC9lcHA6cGhyYXNlPgo8ZXBwOnBo -cmFzZSBpZD0icmVwb3J0X2h0bWxfcHJpbnRfYnRuIj48YSBocmVmPSJqYXZhc2NyaXB0OndpbmRv -dy5wcmludCgpIiBjbGFzcz0iZXBfZm9ybV9hY3Rpb25fYnV0dG9uIGh0bWxfcmVwb3J0X3ByaW50 -IGVwX25vcHJpbnQiPlByaW50PC9hPjwvZXBwOnBocmFzZT4KCjwhLS0gRVByaW50IFJlcG9ydCAt -LT4KPGVwcDpwaHJhc2UgaWQ9IlBsdWdpbi9TY3JlZW4vUmVwb3J0L0VQcmludDp0aXRsZSI+RVBy -aW50czwvZXBwOnBocmFzZT4KPGVwcDpwaHJhc2UgaWQ9ImV4cG9ydGZpZWxkczplcHJpbnRfcmVw -b3J0X2NvcmUiPkV4cG9ydCBGaWVsZHM8L2VwcDpwaHJhc2U+CjxlcHA6cGhyYXNlIGlkPSJlcHJp -bnRfcmVwb3J0OnNvcnQ6Ynl5ZWFyIj5ZZWFyPC9lcHA6cGhyYXNlPgo8ZXBwOnBocmFzZSBpZD0i -ZXByaW50X3JlcG9ydDpzb3J0OmJ5bmFtZSI+Q3JlYXRvcnM8L2VwcDpwaHJhc2U+CjxlcHA6cGhy -YXNlIGlkPSJlcHJpbnRfcmVwb3J0OnNvcnQ6Ynl0aXRsZSI+VGl0bGU8L2VwcDpwaHJhc2U+Cjxl -cHA6cGhyYXNlIGlkPSJlcHJpbnRfcmVwb3J0OnNvcnQ6YnlkaXZpc2lvbiI+RGl2aXNpb248L2Vw -cDpwaHJhc2U+Cgo8ZXBwOnBocmFzZSBpZD0iZXByaW50X3JlcG9ydDpncm91cDpkaXZpc2lvbnMi -PkRpdmlzaW9uPC9lcHA6cGhyYXNlPgo8ZXBwOnBocmFzZSBpZD0iZXByaW50X3JlcG9ydDpncm91 -cDpzdWJqZWN0cyI+U3ViamVjdDwvZXBwOnBocmFzZT4KPGVwcDpwaHJhc2UgaWQ9ImVwcmludF9y -ZXBvcnQ6Z3JvdXA6dHlwZSI+SXRlbSBUeXBlPC9lcHA6cGhyYXNlPgo8ZXBwOnBocmFzZSBpZD0i -ZXByaW50X3JlcG9ydDpncm91cDpkYXRlIj5EYXRlPC9lcHA6cGhyYXNlPgoKPCEtLSBVc2VyIFJl -cG9ydCAtLT4KPGVwcDpwaHJhc2UgaWQ9IlBsdWdpbi9TY3JlZW4vUmVwb3J0L1VzZXI6dGl0bGUi -PlVzZXJzPC9lcHA6cGhyYXNlPgo8ZXBwOnBocmFzZSBpZD0iZXhwb3J0ZmllbGRzOnVzZXJfcmVw -b3J0X2NvcmUiPkV4cG9ydCBGaWVsZHM8L2VwcDpwaHJhc2U+CjxlcHA6cGhyYXNlIGlkPSJ1c2Vy -X3JlcG9ydDpzb3J0OmJ5bmFtZSI+TmFtZTwvZXBwOnBocmFzZT4KCjwhLS0gRml4IGZvciB0eXBv -LWVkIHBocmFzZSBuYW1lIGluIHByZS0zLjQuNiBFUHJpbnRzIC0tPgo8ZXBwOnBocmFzZSBpZD0i -VXBkYXRlL1ZpZXdzOmdyb3VwX3NlcGFyYXRvciI+IHwgPC9lcHA6cGhyYXNlPgoKPC9lcHA6cGhy -YXNlcz4K +LjwvZXBwOnBocmFzZT4KCjxlcHA6cGhyYXNlIGlkPSJVcGRhdGUvVmlld3M6Z3JvdXBfc2VwYXJh +dG9yIj4gfCA8L2VwcDpwaHJhc2U+Cgo8ZXBwOnBocmFzZSBpZD0iUGx1Z2luL1NjcmVlbi9SZXBv +cnQ6dGl0bGUiPlJlcG9ydHM8L2VwcDpwaHJhc2U+CjxlcHA6cGhyYXNlIGlkPSJQbHVnaW4vU2Ny +ZWVuL1JlcG9ydDpub19yZXBvcnRzIj5ObyBhdmFpbGFibGUgcmVwb3J0czwvZXBwOnBocmFzZT4K +CjxlcHA6cGhyYXNlIGlkPSJyZXBvcnRzX3ByZXNldCI+UHJlc2V0IFJlcG9ydHM8L2VwcDpwaHJh +c2U+CjxlcHA6cGhyYXNlIGlkPSJyZXBvcnRzX2N1c3RvbSI+Q3VzdG9tIFJlcG9ydHM8L2VwcDpw +aHJhc2U+Cgo8ZXBwOnBocmFzZSBpZD0iUmVwb3J0OnNvcnRfbGlua3MiPjxkaXYgY2xhc3M9ImVw +X3ZpZXdfZ3JvdXBfYnkiPlNvcnQgYnk6IDxlcGM6cGluIG5hbWU9ImxpbmtzIiAvPjwvZGl2Pjwv +ZXBwOnBocmFzZT4KPGVwcDpwaHJhc2UgaWQ9IlJlcG9ydDpncm91cF9saW5rcyI+PGRpdiBjbGFz +cz0iZXBfdmlld19ncm91cF9ieSI+R3JvdXAgYnk6IDxlcGM6cGluIG5hbWU9ImxpbmtzIiAvPjwv +ZGl2PjwvZXBwOnBocmFzZT4KCjxlcHA6cGhyYXNlIGlkPSJyZXBvcnQ6bm9fZ3JvdXBpbmciPk5v +IEdyb3VwaW5nPC9lcHA6cGhyYXNlPgoKPGVwcDpwaHJhc2UgaWQ9InJlcG9ydF9zZWxlY3QiPlNl +bGVjdC9EZXNlbGVjdCBBbGw8L2VwcDpwaHJhc2U+Cgo8ZXBwOnBocmFzZSBpZD0iUmVwb3J0OnNl +YXJjaF9saW5rcyI+PGRpdiBjbGFzcz0iZXBfdmlld19ncm91cF9ieSI+PGVwYzpwaW4gbmFtZT0i +bGlua3MiIC8+PC9kaXY+PC9lcHA6cGhyYXNlPgoKPGVwcDpwaHJhc2UgaWQ9InJlcG9ydF9zZWxl +Y3RfbGFiZWwiPlNlbGVjdCBSZXBvcnQ6PC9lcHA6cGhyYXNlPgo8ZXBwOnBocmFzZSBpZD0iZXhw +b3J0X3NlbGVjdF9sYWJlbCI+U2VsZWN0IEV4cG9ydCBGb3JtYXQ6PC9lcHA6cGhyYXNlPgoKPCEt +LSB0aGUgRXhhbXBsZSByZXBvcnRzIC0tPgo8ZXBwOnBocmFzZSBpZD0iUGx1Z2luL1NjcmVlbi9S +ZXBvcnQvRXhhbXBsZTp0aXRsZSI+RXhhbXBsZTwvZXBwOnBocmFzZT4KPGVwcDpwaHJhc2UgaWQ9 +IlBsdWdpbi9TY3JlZW4vUmVwb3J0L0V4YW1wbGUvQXJ0aWNsZXM6dGl0bGUiPkFydGljbGVzPC9l +cHA6cGhyYXNlPgo8ZXBwOnBocmFzZSBpZD0iUGx1Z2luL1NjcmVlbi9SZXBvcnQvRXhhbXBsZS9D +b25mZXJlbmNlSXRlbXM6dGl0bGUiPkNvbmZlcmVuY2UgSXRlbXM8L2VwcDpwaHJhc2U+Cgo8ZXBw +OnBocmFzZSBpZD0iZXhwb3J0X3RpdGxlIj5FeHBvcnQgT3B0aW9uczwvZXBwOnBocmFzZT4KCjwh +LS0gSFRNTCBFeHBvcnQgLS0+CjxlcHA6cGhyYXNlIGlkPSJyZXBvcnRfaHRtbF9leHBvcnRfdGl0 +bGUiPlJlcG9ydDwvZXBwOnBocmFzZT4KPGVwcDpwaHJhc2UgaWQ9InJlcG9ydF9odG1sX3ByaW50 +X2J0biI+PGEgaHJlZj0iamF2YXNjcmlwdDp3aW5kb3cucHJpbnQoKSIgY2xhc3M9ImVwX2Zvcm1f +YWN0aW9uX2J1dHRvbiBodG1sX3JlcG9ydF9wcmludCBlcF9ub3ByaW50Ij5QcmludDwvYT48L2Vw +cDpwaHJhc2U+Cgo8IS0tIEVQcmludCBSZXBvcnQgLS0+CjxlcHA6cGhyYXNlIGlkPSJQbHVnaW4v +U2NyZWVuL1JlcG9ydC9FUHJpbnQ6dGl0bGUiPkVQcmludHM8L2VwcDpwaHJhc2U+CjxlcHA6cGhy +YXNlIGlkPSJleHBvcnRmaWVsZHM6ZXByaW50X3JlcG9ydF9jb3JlIj5FeHBvcnQgRmllbGRzPC9l +cHA6cGhyYXNlPgo8ZXBwOnBocmFzZSBpZD0iZXByaW50X3JlcG9ydDpzb3J0OmJ5eWVhciI+WWVh +cjwvZXBwOnBocmFzZT4KPGVwcDpwaHJhc2UgaWQ9ImVwcmludF9yZXBvcnQ6c29ydDpieW5hbWUi +PkNyZWF0b3JzPC9lcHA6cGhyYXNlPgo8ZXBwOnBocmFzZSBpZD0iZXByaW50X3JlcG9ydDpzb3J0 +OmJ5dGl0bGUiPlRpdGxlPC9lcHA6cGhyYXNlPgo8ZXBwOnBocmFzZSBpZD0iZXByaW50X3JlcG9y +dDpzb3J0OmJ5ZGl2aXNpb24iPkRpdmlzaW9uPC9lcHA6cGhyYXNlPgoKPGVwcDpwaHJhc2UgaWQ9 +ImVwcmludF9yZXBvcnQ6Z3JvdXA6ZGl2aXNpb25zIj5EaXZpc2lvbjwvZXBwOnBocmFzZT4KPGVw +cDpwaHJhc2UgaWQ9ImVwcmludF9yZXBvcnQ6Z3JvdXA6c3ViamVjdHMiPlN1YmplY3Q8L2VwcDpw +aHJhc2U+CjxlcHA6cGhyYXNlIGlkPSJlcHJpbnRfcmVwb3J0Omdyb3VwOnR5cGUiPkl0ZW0gVHlw +ZTwvZXBwOnBocmFzZT4KPGVwcDpwaHJhc2UgaWQ9ImVwcmludF9yZXBvcnQ6Z3JvdXA6ZGF0ZSI+ +RGF0ZTwvZXBwOnBocmFzZT4KCjwhLS0gVXNlciBSZXBvcnQgLS0+CjxlcHA6cGhyYXNlIGlkPSJQ +bHVnaW4vU2NyZWVuL1JlcG9ydC9Vc2VyOnRpdGxlIj5Vc2VyczwvZXBwOnBocmFzZT4KPGVwcDpw +aHJhc2UgaWQ9ImV4cG9ydGZpZWxkczp1c2VyX3JlcG9ydF9jb3JlIj5FeHBvcnQgRmllbGRzPC9l +cHA6cGhyYXNlPgo8ZXBwOnBocmFzZSBpZD0idXNlcl9yZXBvcnQ6c29ydDpieW5hbWUiPk5hbWU8 +L2VwcDpwaHJhc2U+Cgo8L2VwcDpwaHJhc2VzPgo= + document plugins/EPrints/Plugin/Export/Grid2.pm text/plain - 83d730999923d798d1acbb44c4a91667 + ce4f81455c6bb8b5c0977a5e18836984 MD5 - 10222 + 13974 PWhlYWQxIE5BTUUKCkVQcmludHM6OlBsdWdpbjo6RXhwb3J0OjpHcmlkMgoKPWN1dAoKcGFja2Fn ZSBFUHJpbnRzOjpQbHVnaW46OkV4cG9ydDo6R3JpZDI7Cgp1c2UgRGF0YTo6RHVtcGVyOwp1c2Ug RVByaW50czo6UGx1Z2luOjpFeHBvcnQ7CgpASVNBID0gKCAiRVByaW50czo6UGx1Z2luOjpFeHBv cnQ6OkdyaWQiICk7Cgp1c2Ugc3RyaWN0OwoKJEVQcmludHM6OlBsdWdpbjo6SW1wb3J0OjpESVNB -QkxFID0gMTsKCnN1YiBuZXcKewoJbXkoICRjbGFzcywgJW9wdHMgKSA9IEBfOwoKCW15ICRzZWxm -ID0gJGNsYXNzLT5TVVBFUjo6bmV3KCAlb3B0cyApOwoKCSRzZWxmLT57bmFtZX0gPSAiR3JpZCAy -IChhYnN0cmFjdCkiOwoJJHNlbGYtPnthY2NlcHR9ID0gWyAnZGF0YW9iai8qJywgJ2xpc3QvKics -IF07Cgkkc2VsZi0+e3Zpc2libGV9ID0gIm5vbmUiOwkKCSRzZWxmLT57YWR2ZXJ0aXNlfSA9IDA7 -CQoJcmV0dXJuICRzZWxmOwp9CgpzdWIgZmllbGRzCnsKCW15KCAkc2VsZiwgJGRhdGFzZXQgKSA9 -IEBfOwoKCSMgc2tpcCBjb21wb3VuZCwgc3Vib2JqZWN0cwoJI3JldHVybiBncmVwIHsgISRfLT5p -c192aXJ0dWFsIH0gJGRhdGFzZXQtPmZpZWxkczsKCQoJbXkgQGZpZWxkbmFtZXM7Cglmb3JlYWNo -IG15ICRmICggJGRhdGFzZXQtPmZpZWxkcyApCgl7CgkJaWYoICEkZi0+aXNfdmlydHVhbCApCgkJ -ewoJCQlwdXNoIEBmaWVsZG5hbWVzLCAkZi0+bmFtZTsKCQl9Cgl9CglyZXR1cm4gXEBmaWVsZG5h -bWVzOwp9CgpzdWIgaGVhZGVyX3Jvdwp7CglteSggJHNlbGYsICVvcHRzICkgPSBAXzsKCglteSAk -ZmllbGRzID0gJG9wdHN7ZmllbGRzfSB8fD0gWyRzZWxmLT5maWVsZHMoJG9wdHN7bGlzdH0tPntk -YXRhc2V0fSldOwoJbXkgJGRzID0gJG9wdHN7bGlzdH0tPntkYXRhc2V0fTsKCglteSBAbmFtZXM7 -Cglmb3JlYWNoIG15ICRmIChAJGZpZWxkcykKCXsKCQlpZiggZGVmaW5lZCAkb3B0c3tjdXN0b21f -ZXhwb3J0fSAmJiBkZWZpbmVkICRvcHRze2N1c3RvbV9leHBvcnR9LT57JGZ9ICkKICAgICAgICAg -ICAgICAgIHsKICAgICAgICAgICAgICAgIAlwdXNoIEBuYW1lcywgJGRzLT5yZXBvc2l0b3J5LT5o -dG1sX3BocmFzZSggImV4cG9ydGZpZWxkb3B0aW9uczokZiIgKTsKICAgICAgICAgICAgICAgIH0K -CQllbHNlCgkJewoJCQlteSAkZmllbGQgPSBFUHJpbnRzOjpVdGlsczo6ZmllbGRfZnJvbV9jb25m -aWdfc3RyaW5nKCAkZHMsICRmICk7CgoJCQlpZiAoJGZpZWxkLT5pc2EoIkVQcmludHM6Ok1ldGFG -aWVsZDo6TXVsdGlwYXJ0IikpCgkJCXsKCQkJCW15ICRwYXJlbnRfbmFtZSA9ICRmaWVsZC0+cmVu -ZGVyX25hbWU7CgkJCQlpZiggJGZpZWxkLT5pc2EoICJFUHJpbnRzOjpNZXRhRmllbGQ6Ok5hbWUi -ICkpICNuZWVkIHRvIGRlYWwgd2l0aCBsZWdhY3kgcGhyYXNlIGlkJ3MKCQkJCXsKCQkJCQlmb3Jl -YWNoIG15ICRiaXQgKCAkZmllbGQtPmdldF9pbnB1dF9iaXRzKCkgKQoJCQkJICAgICAgICB7CgkJ -CQkJCSRiaXQgPSAiZ2l2ZW5fbmFtZXMiIGlmKCAkYml0IGVxICJnaXZlbiIgKTsKICAgICAgICAg -ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAJJGJpdCA9ICJmYW1pbHlfbmFt -ZXMiIGlmKCAkYml0IGVxICJmYW1pbHkiICk7CgkJCQkJCW15ICRjdXN0b21fcGhyYXNlID0gJGZp -ZWxkLT5uYW1lIC4gIl8iIC4gJGJpdDsKCQkJCQkJaWYoICRkcy0+cmVwb3NpdG9yeS0+Z2V0X2xh -bmctPmhhc19waHJhc2UoICRjdXN0b21fcGhyYXNlICkgKSAjYWxsb3cgYSBjdXN0b20gcGhyYXNl -IHRvIGJlIHVzZWQKCQkJCQkJewoJCQkJCQkJcHVzaCBAbmFtZXMsICRkcy0+cmVwb3NpdG9yeS0+ -aHRtbF9waHJhc2UoICRjdXN0b21fcGhyYXNlICk7CgkJCQkJCX0KCQkJCQkJZWxzZQoJCQkJCQl7 -CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAlwdXNoIEBu -YW1lcywgJHBhcmVudF9uYW1lIC4gIjogIiAuICRkcy0+cmVwb3NpdG9yeS0+aHRtbF9waHJhc2Uo -ICJsaWIvbWV0YWZpZWxkOiIuJGJpdCApOwoJCQkJCQl9CiAgICAgICAgICAgICAgICAgICAgICAg -ICAgICAgICAgICAgICAgICB9CgkJCQl9CgkJCQllbHNlCgkJCQl7CgkJCQkJbXkgJG5hbWUgPSAk -ZmllbGQtPm5hbWU7CgkJCQkJcHVzaCBAbmFtZXMsIG1hcCB7CgkJCQkJCSRuYW1lIC4gJy4nIC4g -JF8tPntzdWJfbmFtZX0KCQkJCQl9IEB7JGZpZWxkLT5wcm9wZXJ0eSgiZmllbGRzX2NhY2hlIil9 -OwoJCQkJfQoJCQl9CgkJCWVsc2lmKCAkZmllbGQtPmlzYSgiRVByaW50czo6TWV0YUZpZWxkOjpD -b21wb3VuZCIgKSApCgkJCXsKCQkJCWZvcmVhY2ggbXkgJHN1Yl9maWVsZCAoQHskZmllbGQtPnBy -b3BlcnR5KCJmaWVsZHNfY2FjaGUiKX0pCgkJCQl7CgkJCQkJbXkgJGN1c3RvbV9waHJhc2UgPSAk -ZmllbGQtPm5hbWUgLiAiXyIgLiAkc3ViX2ZpZWxkLT5uYW1lOwoJCQkJCWlmKCAkZHMtPnJlcG9z -aXRvcnktPmdldF9sYW5nLT5oYXNfcGhyYXNlKCAkY3VzdG9tX3BocmFzZSApICkgI2FsbG93IGEg -Y3VzdG9tIHBocmFzZSB0byBiZSB1c2VkCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg -ICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAJcHVzaCBA -bmFtZXMsICRkcy0+cmVwb3NpdG9yeS0+aHRtbF9waHJhc2UoICRjdXN0b21fcGhyYXNlICk7CiAg -ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB9CgkJCQkJZWxzZQoJCQkJCXsK -CQkJCQkJcHVzaCBAbmFtZXMsICRmaWVsZC0+cmVuZGVyX25hbWUgLiAiOiAiIC4gJHN1Yl9maWVs -ZC0+cmVuZGVyX25hbWU7CgkJCQkJfQoJCQkJfQoJCQl9CgkJCWVsc2UKCQkJewoJCQkJcHVzaCBA -bmFtZXMsICRmaWVsZC0+cmVuZGVyX25hbWU7CgkJCX0KCQl9Cgl9CQkKCXJldHVybiBAbmFtZXM7 -Cn0KCnN1YiBkYXRhb2JqX3RvX3Jvd3MKewoJbXkoICRzZWxmLCAkZGF0YW9iaiwgJW9wdHMgKSA9 -IEBfOwoKCW15ICRtYWluX2RhdGFvYmogPSAkZGF0YW9iajsgI3N0b3JlIGRhdGFvYmogZm9yIGZ1 -dHVyZSByZWZlcmVuY2UKCglteSAkZmllbGRzID0gJG9wdHN7ZmllbGRzfSB8fCBbJHNlbGYtPmZp -ZWxkcygkZGF0YW9iai0+e2RhdGFzZXR9KV07CglteSAkZHMgPSAkb3B0c3tsaXN0fS0+e2RhdGFz -ZXR9OwoKCW15IEByb3dzID0gKFtdKTsKCWZvcmVhY2ggbXkgJGZuYW1lIChAJGZpZWxkcykKCXsK -CQkjcmVzZXQgZGF0YW9iaiB0byBtYWluIGRhdGFvYmoKCQkkZGF0YW9iaiA9ICRtYWluX2RhdGFv -Ymo7CgoJCSNnZXQgdGhlIGZpZWxkIGZyb20gdGhlIGlkCgkJbXkgJGZpZWxkOwoJCW15IEBmbmFt -ZXMgPSBzcGxpdCggL1wuLywgJGZuYW1lICk7CgkJbXkgJHN1Yl9kYXRhb2JqX3ZhbHVlcyA9IFtd -OwkJCgkJaWYoIHNjYWxhciggQGZuYW1lcyA+IDEgKSApICNhIGZpZWxkIG9mIGFub3RoZXIgZGF0 -YXNldCwgZS5nLiBkb2N1bWVudHMuY29udGVudAogICAgICAgICAgICAgICAgewoJCQkkZmllbGQg -PSAkZHMtPmdldF9maWVsZCggJGZuYW1lc1swXSApOyAjZmlyc3QgZ2V0IHRoZSBmaWVsZAoJCQlp -ZiggJGZpZWxkLT5pc190eXBlKCAic3Vib2JqZWN0IiwgIml0ZW1yZWYiICkgKSAjaWYgdGhlIGZp -ZWxkIGJlbG9uZ3MgdG8gYW5vdGhlciBkYXRhc2V0CiAgICAgICAgICAgICAgICAgICAgICAgIHsK -CQkJCW15ICRzdWJfZHNfaWQgPSAkZmllbGQtPmdldF9wcm9wZXJ0eSggImRhdGFzZXRpZCIgKTsK -CQkJCW15ICRtdWx0aXBsZSA9ICRmaWVsZC0+Z2V0X3Byb3BlcnR5KCAibXVsdGlwbGUiICk7CgkJ -CQlpZiggJG11bHRpcGxlICkKCQkJCXsKCQkJCQlteSBAc3ViX2RhdGFvYmpzOwoJCQkJCSNnZXQg -dGhlIGRhdGFvYmpzIG9mIHRoaXMgZmllbGQKCQkJCQlpZiggJHN1Yl9kc19pZCBlcSAiZG9jdW1l -bnQiICkgI2RvY3VtZW50cyByZXByZXNlbnQgYSBzcGVjaWFsIGNhc2Ugb2Ygc3ViIG9iamVjdCAt -IHdlIGRvbid0IHdhbnQgdm9sYXRpbGUgZG9jdW1lbnRzIChwcm9iYWJseSkKICAgICAgICAgICAg -ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHsJCgkJCQkJCUBzdWJfZGF0YW9ianMgPSAkZGF0 -YW9iai0+Z2V0X2FsbF9kb2N1bWVudHM7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg -ICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbHNlCiAg -ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB7CgkJCQkJCWZvcmVhY2ggbXkg -JHN1Yl9vYmogKCBAeyRkYXRhb2JqLT52YWx1ZSggJGZuYW1lc1swXSApfSApCgkJCQkJCXsKCQkJ -CQkJCXB1c2ggQHN1Yl9kYXRhb2JqcywgJGZpZWxkLT5nZXRfaXRlbSggJGRhdGFvYmotPnJlcG9z -aXRvcnksICRzdWJfb2JqICk7CgkJCQkJCX0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg -ICAgICAgICAgIH0KCQkJCQkKCQkJCQkjYW5kIGJ1aWxkIHVwIGFuIGFycmF5IG9mIHRoZXNlIHN1 -YiBkYXRhb2JqJ3MgdmFsdWVzCgkJCQkJZm9yZWFjaCBteSAkb2JqICggQHN1Yl9kYXRhb2JqcyAp -ICNnZXQgdGhlIHZhbHVlcyB3ZSBhcmUgcmVxdWVzdGluZyBvZiB0aGUgZGF0YW9iamVjdHMKICAg -ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHsKCQkJCQkJI2NoZWNrIGZvciBh -IGN1c3RvbSByZW5kZXJlcgoJCQkJCQlteSAkdmFsdWU7CgkJCQkJCWlmKCBkZWZpbmVkICRvcHRz -e2N1c3RvbV9leHBvcnR9ICYmIGRlZmluZWQgJG9wdHN7Y3VzdG9tX2V4cG9ydH0tPnskZm5hbWV9 -ICkKCQkJCQkJewoJCQkJCQkJJHZhbHVlID0gJG9wdHN7Y3VzdG9tX2V4cG9ydH0tPnskZm5hbWV9 -LT4oICRvYmosICRvcHRze3BsdWdpbn0gKTsKCQkJCQkJfQoJCQkJCQllbHNlCgkJCQkJCXsJCQkJ -CQkJCgkJCQkJCQkkZmllbGQgPSBFUHJpbnRzOjpVdGlsczo6ZmllbGRfZnJvbV9jb25maWdfc3Ry -aW5nKCAkb2JqLT5kYXRhc2V0LCAkZm5hbWVzWzFdICk7CQkJCQkJCQoJCQkJCQkJaWYoICRmaWVs -ZC0+Z2V0X3Byb3BlcnR5KCAidmlydHVhbCIgKSApICN2aXJ0dWFsIGZpZWxkcyBuZWVkIHJlbmRl -cmluZwoJCQkJCQkJewoJCQkJCQkJCSR2YWx1ZSA9IEVQcmludHM6OlV0aWxzOjp0cmVlX3RvX3V0 -ZjgoICRvYmotPnJlbmRlcl92YWx1ZSggJGZuYW1lc1sxXSApICk7CgkJCQkJCQl9CgkJCQkJCQll -bHNlICNyZWd1bGFyIGZpZWxkIHZhbHVlcyBjYW4gc2ltcGx5IGJlIHJldHJpZXZlZAoJCQkJCQkJ -ewoJCQkJCQkJCSR2YWx1ZSA9ICRmaWVsZC0+Z2V0X3ZhbHVlKCAkb2JqICk7CgkJCQkJCQl9CgkJ -CQkJCX0KCQkJCQkJcHVzaCBAeyRzdWJfZGF0YW9ial92YWx1ZXN9LCAkdmFsdWU7IAoJCQkJCX0K -CQkJCX0KCQkJCWVsc2UgI3dlIG9ubHkgaGF2ZSBvbmUgc3ViLW9iamVjdCwgCgkJCQl7CgkJCQkJ -bXkgJHN1Yl9vYmogPSAkZmllbGQtPmdldF9pdGVtKCAkZGF0YW9iai0+cmVwb3NpdG9yeSwgJGRh -dGFvYmotPnZhbHVlKCAkZm5hbWVzWzBdICkgKTsgI2dldCB0aGUgc3Vib2JqZWN0CgkJCQkJJGZp -ZWxkID0gRVByaW50czo6VXRpbHM6OmZpZWxkX2Zyb21fY29uZmlnX3N0cmluZyggJHN1Yl9vYmot -PmRhdGFzZXQsICRmbmFtZXNbMV0gKTsgI2dldCB0aGUgc3Vib2JqZWN0cyBmaWVsZAoJCQkJCW15 -ICR2YWx1ZSA9ICRmaWVsZC0+Z2V0X3ZhbHVlKCAkc3ViX29iaiApOyAjZ2V0IHRoZSBzdWJvYmpl -Y3RzIHZhbHVlIGZvciB0aGlzIGZpZWxkCgkJCQkJcHVzaCBAeyRzdWJfZGF0YW9ial92YWx1ZXN9 -LCAkdmFsdWU7CQkJCQkJCgkJCQl9CgkJCX0KCQl9CgoJCW15ICRpID0gQHskcm93c1swXX07CgkJ -bXkgJF9yb3dzOwoJCWlmKCBFUHJpbnRzOjpVdGlsczo6aXNfc2V0KCAkZmllbGQgKSApICN3ZSBh -bHJlYWR5IGhhdmUgb3VyIHZhbHVlcwoJCXsKCQkJaWYoIHNjYWxhciBAeyRzdWJfZGF0YW9ial92 -YWx1ZXN9ID4gMCApCgkJCXsKCQkJCSRfcm93cyA9ICRzZWxmLT52YWx1ZV90b19yb3dzKCRmaWVs -ZCwgJHN1Yl9kYXRhb2JqX3ZhbHVlcywgJGRhdGFvYmopOwkJCQoJCQl9CgkJCWVsc2UgI3RoZXJl -J3Mgbm8gcmVzdWx0cywgYnV0IHdlIHN0aWxsIG5lZWQgdG8gYWRkIGFuIGVtcHR5IGNlbGwgdG8g -dGhlIHNwcmVhZHNoZWV0CgkJCXsKCQkJCSRfcm93cyA9ICRzZWxmLT52YWx1ZV90b19yb3dzKCRm -aWVsZCwgdW5kZWYpOwoJCQl9CgkJfQoJCWVsc2UgI3dlIG5lZWQgdG8gcmV0cmlldmUgb3VyIHZh -bHVlcyBmb3IgdGhpcyBmaWVsZCBmcm9tIG91ciBkYXRhb2JqIChvciBzdWJfZGF0YW9iaikKCQl7 -CgkJCW15ICR2YWx1ZTsKCQkJaWYoIGRlZmluZWQgJG9wdHN7Y3VzdG9tX2V4cG9ydH0gJiYgZGVm -aW5lZCAkb3B0c3tjdXN0b21fZXhwb3J0fS0+eyRmbmFtZX0gKSAjd2UgaGF2ZSBhIGN1c3RvbSBl -eHBvcnRlcgoJCQl7CgkJCQkkdmFsdWUgPSAkb3B0c3tjdXN0b21fZXhwb3J0fS0+eyRmbmFtZX0t -PiggJGRhdGFvYmosICRvcHRze3BsdWdpbn0gKTsKCQkJCSRfcm93cyA9ICRzZWxmLT5jdXN0b21f -dmFsdWVfdG9fcm93cyggJHZhbHVlICk7CgkJCX0KCQkJZWxzZSAjanVzdCBnZXQgdGhlIGZpZWxk -J3MgdXN1YWwgdmFsdWUKCQkJewoJCQkJJGZpZWxkID0gRVByaW50czo6VXRpbHM6OmZpZWxkX2Zy -b21fY29uZmlnX3N0cmluZyggJGRzLCAkZm5hbWUgKTsKCQkJCWlmKCAkZmllbGQtPmdldF9wcm9w -ZXJ0eSggInZpcnR1YWwiICkgKSAjdmlydHVhbCBmaWVsZHMgbmVlZCByZW5kZXJpbmcKCQkJCXsK -CQkJCQkkdmFsdWUgPSBFUHJpbnRzOjpVdGlsczo6dHJlZV90b191dGY4KCAkZGF0YW9iai0+cmVu -ZGVyX3ZhbHVlKCAkZm5hbWUgKSApOwoJCQkJfQoJCQkJZWxzZSAjcmVndWxhciBmaWVsZCB2YWx1 -ZXMgY2FuIHNpbXBseSBiZSByZXRyaWV2ZWQKCQkJCXsKCQkJCQkkdmFsdWUgPSAkZmllbGQtPmdl -dF92YWx1ZSggJGRhdGFvYmogKTsKCQkJCX0KCQkJCSRfcm93cyA9ICRzZWxmLT52YWx1ZV90b19y -b3dzKCRmaWVsZCwgJHZhbHVlLCAkZGF0YW9iaik7IAkJCgkJCX0JCQkKCQl9CgoJCWZvcmVhY2gg -bXkgJGogKDAuLiQjJF9yb3dzKQoJCXsKCQkJZm9yZWFjaCBteSAkX2kgKDAuLiQjeyRfcm93cy0+ -WyRqXX0pCgkJCXsKCQkJCSRyb3dzWyRqXVskaSskX2ldID0gJF9yb3dzLT5bJGpdWyRfaV07CgkJ -CX0KCQl9Cgl9CgoJIyBnZW5lcmF0ZSBjb21wbGV0ZSByb3dzCglpZigkb3B0c3twbHVnaW59LT5w -YXJhbSggIm11bHRpbGluZV9yZXBlYXQiICkpICN3ZSB3YW50IGVhY2ggY29sdW1uIHRvIHJlcGVh -dCBmb3IgZWFjaCByb3cKCXsKCQlmb3JlYWNoIG15ICRpICgwLi4oc2NhbGFyIEByb3dzKS0xKQoJ -CXsKCQkJZm9yZWFjaCBteSAkaiAoMC4uJCN7JHJvd3NbMF19KQoJCQl7CgkJCQkkcm93c1skaV1b -JGpdIHx8PSAkcm93c1swXVskal07CgkJCX0JCgkJfQoJfQoJZWxzZSAjd2UgZG9uJ3Qgd2FudCBy -ZXBlYXRpbmcgdmFsdWVzIGluIHRoZSBjb2x1bW5zCgl7CQoJCWZvcihAcm93cykgewoJCQkkXy0+ -WzBdID0gJHJvd3NbMF1bMF07ICNmaXJzdCBlbGVtZW50IG9mIHRoaXMgYXJyYXkgZXF1YWxzIHRo -ZSBmaXJzdCBlbGVtZW50IG9mIHRoZSBmaXJzdCByb3cKCQkJJF8tPlskI3skcm93c1swXX1dIHx8 -PSB1bmRlZjsKCQl9CgoJfQoKCXJldHVybiBcQHJvd3M7Cn0KCnN1YiB2YWx1ZV90b19yb3dzCnsK -CW15ICgkc2VsZiwgJGZpZWxkLCAkdmFsdWUsICRkYXRhb2JqKSA9IEBfOwoKCW15IEByb3dzOwoK -CWlmIChyZWYoJHZhbHVlKSBlcSAiQVJSQVkiKQoJewoJCSR2YWx1ZSA9IFskZmllbGQtPmVtcHR5 -X3ZhbHVlXSBpZiAhQCR2YWx1ZTsKCQlAcm93cyA9IG1hcCB7ICRzZWxmLT52YWx1ZV90b19yb3dz -KCRmaWVsZCwgJF8sICRkYXRhb2JqKS0+WzBdIH0gQCR2YWx1ZTsKCX0KCWVsc2lmICgkZmllbGQt -PmlzYSgiRVByaW50czo6TWV0YUZpZWxkOjpNdWx0aXBhcnQiKSkKCXsKCQlpZiggJGZpZWxkLT5p -c2EoICJFUHJpbnRzOjpNZXRhRmllbGQ6Ok5hbWUiICkpICNuZWVkIHRvIGRlYWwgd2l0aCBsZWdh -Y3kgcGhyYXNlIGlkJ3MKICAgICAgICAgICAgICAgIHsKCQkJbXkgQGJpdF92YWx1ZXM7CgkJCWZv -cmVhY2ggbXkgJGJpdCAoICRmaWVsZC0+Z2V0X2lucHV0X2JpdHMoKSApCiAgICAgICAgICAgICAg -ICAgICAgICAgIHsKCQkJCXB1c2ggQGJpdF92YWx1ZXMsICR2YWx1ZS0+eyRiaXR9OwogICAgICAg -IAkJfQkKCQkJcHVzaCBAcm93cywgXEBiaXRfdmFsdWVzOwoJICAgICAgICB9CgkJZWxzZQoJCXsK -CQkJcHVzaCBAcm93cywgW21hcCB7ICR2YWx1ZS0+eyRfLT57c3ViX25hbWV9fSB9IEB7JGZpZWxk -LT5wcm9wZXJ0eSgiZmllbGRzX2NhY2hlIil9XTsKCQl9Cgl9CgllbHNpZiAoJGZpZWxkLT5pc2Eo -IkVQcmludHM6Ok1ldGFGaWVsZDo6Q29tcG91bmQiKSkKCXsKCQlteSBAc3ViX3ZhbHVlczsKCQlm -b3JlYWNoIG15ICRrZXkgKGtleXMgJXskdmFsdWV9KQoJCXsKCQkJcHVzaCBAc3ViX3ZhbHVlcywg -JHZhbHVlLT57JGtleX07CgkJfQoJCXB1c2ggQHJvd3MsIFxAc3ViX3ZhbHVlczsKCX0KCWVsc2lm -KCAkZmllbGQtPmlzYSgiRVByaW50czo6TWV0YUZpZWxkOjpTdWJqZWN0IikpCiAgICAgICAgewog -ICAgICAgICAgICAgICAgaWYoICR2YWx1ZSBuZSAiIiApCiAgICAgICAgICAgICAgICB7CiAgICAg -ICAgICAgICAgICAgICAgICAgIHB1c2ggQHJvd3MsIFskZmllbGQtPnJlbmRlcl9zaW5nbGVfdmFs -dWUoICRmaWVsZC0+cmVwb3NpdG9yeSwgJHZhbHVlICldOwogICAgICAgICAgICAgICAgfQogICAg -ICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAg -ICBwdXNoIEByb3dzLCBbJHZhbHVlXTsKICAgICAgICAgICAgICAgIH0KICAgICAgICB9CgllbHNp -ZiggISRmaWVsZC0+aXNhKCJFUHJpbnRzOjpNZXRhRmllbGQ6OlN1Ym9iamVjdCIpICYmICRmaWVs -ZC0+aXNfdmlydHVhbCApCgl7CgkJcHVzaCBAcm93cywgWyRkYXRhb2JqLT5yZW5kZXJfdmFsdWUo -ICRmaWVsZC0+bmFtZSApXTsKCX0KCWVsc2UKCXsKCQlwdXNoIEByb3dzLCBbJHZhbHVlXTsKCX0K -CglyZXR1cm4gXEByb3dzOwp9CgojdXNlZCBmb3IgY3VzdG9tIGV4cG9ydHMgdGhhdCBtaWdodCBy -ZXR1cm4gYSBmaWVsZCBvciBhbiBhcnJheSAoYnV0IGFyZW4ndCBuZWNlc2FyaWx5IGFzc29jaWF0 -ZWQgd2l0aCBhIGZpZWxkISkKc3ViIGN1c3RvbV92YWx1ZV90b19yb3dzCnsKICAgICAgICBteSAo -JHNlbGYsICR2YWx1ZSkgPSBAXzsKCiAgICAgICAgbXkgQHJvd3M7CgogICAgICAgIGlmIChyZWYo -JHZhbHVlKSBlcSAiQVJSQVkiKQogICAgICAgIHsKICAgICAgICAgICAgICAgIEByb3dzID0gbWFw -IHsgJHNlbGYtPmN1c3RvbV92YWx1ZV90b19yb3dzKCRfKS0+WzBdIH0gQCR2YWx1ZTsKICAgICAg -ICB9CiAgICAgICAgZWxzZQogICAgICAgIHsKICAgICAgICAgICAgICAgIHB1c2ggQHJvd3MsIFsk -dmFsdWVdOwogICAgICAgIH0KCiAgICAgICAgcmV0dXJuIFxAcm93czsKfQoKCjE7Cgo9aGVhZDEg -Q09QWVJJR0hUCgo9Zm9yIENPUFlSSUdIVCBCRUdJTgoKQ29weXJpZ2h0IDIwMDAtMjAxMSBVbml2 -ZXJzaXR5IG9mIFNvdXRoYW1wdG9uLgoKPWZvciBDT1BZUklHSFQgRU5ECgo9Zm9yIExJQ0VOU0Ug -QkVHSU4KClRoaXMgZmlsZSBpcyBwYXJ0IG9mIEVQcmludHMgTDxodHRwOi8vd3d3LmVwcmludHMu -b3JnLz4uCgpFUHJpbnRzIGlzIGZyZWUgc29mdHdhcmU6IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0 -IGFuZC9vciBtb2RpZnkgaXQKdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVy -YWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkCmJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5k -YXRpb24sIGVpdGhlciB2ZXJzaW9uIDMgb2YgdGhlIExpY2Vuc2UsIG9yCihhdCB5b3VyIG9wdGlv -bikgYW55IGxhdGVyIHZlcnNpb24uCgpFUHJpbnRzIGlzIGRpc3RyaWJ1dGVkIGluIHRoZSBob3Bl -IHRoYXQgaXQgd2lsbCBiZSB1c2VmdWwsIGJ1dCBXSVRIT1VUCkFOWSBXQVJSQU5UWTsgd2l0aG91 -dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mIE1FUkNIQU5UQUJJTElUWSBvcgpGSVRORVNT -IEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1 -YmxpYwpMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCgpZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQg -YSBjb3B5IG9mIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCkxpY2Vuc2UgYWxvbmcgd2l0 -aCBFUHJpbnRzLiAgSWYgbm90LCBzZWUgTDxodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvPi4K -Cj1mb3IgTElDRU5TRSBFTkQKCg== +QkxFID0gMTsKCnN1YiBuZXcKewogICAgbXkoICRjbGFzcywgJW9wdHMgKSA9IEBfOwoKICAgIG15 +ICRzZWxmID0gJGNsYXNzLT5TVVBFUjo6bmV3KCAlb3B0cyApOwoKICAgICRzZWxmLT57bmFtZX0g +PSAiR3JpZCAyIChhYnN0cmFjdCkiOwogICAgJHNlbGYtPnthY2NlcHR9ID0gWyAnZGF0YW9iai8q +JywgJ2xpc3QvKicsIF07CiAgICAkc2VsZi0+e3Zpc2libGV9ID0gIm5vbmUiOyAgCiAgICAkc2Vs +Zi0+e2FkdmVydGlzZX0gPSAwOyAKICAgIHJldHVybiAkc2VsZjsKfQoKc3ViIGZpZWxkcwp7CiAg +ICBteSggJHNlbGYsICRkYXRhc2V0ICkgPSBAXzsKCiAgICAjIHNraXAgY29tcG91bmQsIHN1Ym9i +amVjdHMKICAgICMgcmV0dXJuIGdyZXAgeyAhJF8tPmlzX3ZpcnR1YWwgfSAkZGF0YXNldC0+Zmll +bGRzOwogICAgCiAgICBteSBAZmllbGRuYW1lczsKICAgIGZvcmVhY2ggbXkgJGYgKCAkZGF0YXNl +dC0+ZmllbGRzICkKICAgIHsKICAgICAgICBpZiggISRmLT5pc192aXJ0dWFsICkKICAgICAgICB7 +CiAgICAgICAgICAgIHB1c2ggQGZpZWxkbmFtZXMsICRmLT5uYW1lOwogICAgICAgIH0KICAgIH0K +ICAgIHJldHVybiBcQGZpZWxkbmFtZXM7Cn0KCnN1YiBoZWFkZXJfcm93CnsKICAgIG15KCAkc2Vs +ZiwgJW9wdHMgKSA9IEBfOwoKICAgIG15ICRmaWVsZHMgPSAkb3B0c3tmaWVsZHN9IHx8PSBbJHNl +bGYtPmZpZWxkcygkb3B0c3tsaXN0fS0+e2RhdGFzZXR9KV07CiAgICBteSAkZHMgPSAkb3B0c3ts +aXN0fS0+e2RhdGFzZXR9OwoKICAgIG15IEBuYW1lczsKCiAgICAjIG9wdGlvbiB0byBub3QgdXNl +IHBocmFzZXMgYW5kIGp1c3QgdXNlIGZpZWxkIG5hbWVzCiAgICBteSAkdXNlX2lkcyA9ICRvcHRz +e3BsdWdpbn0tPnt1c2VfaWRzfSB8fD0gMDsKICAgIGlmKCAkdXNlX2lkcyApCiAgICB7CiAgICAg +ICAgZm9yZWFjaCBteSAkZiAoQCRmaWVsZHMpCiAgICAgICAgeyAgICAgICAgICAgIAogICAgICAg +ICAgICBpZiggZGVmaW5lZCAkb3B0c3tjdXN0b21fZXhwb3J0fSAmJiBkZWZpbmVkICRvcHRze2N1 +c3RvbV9leHBvcnR9LT57JGZ9ICkKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgcHVzaCBA +bmFtZXMsICRmOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgewog +ICAgICAgICAgICAgICAgbXkgJGZpZWxkID0gRVByaW50czo6VXRpbHM6OmZpZWxkX2Zyb21fY29u +ZmlnX3N0cmluZyggJGRzLCAkZiApOwogICAgICAgICAgICAgICAgaWYoICRmaWVsZC0+aXNhKCAi +RVByaW50czo6TWV0YUZpZWxkOjpNdWx0aXBhcnQiICkgKQogICAgICAgICAgICAgICAgewogICAg +ICAgICAgICAgICAgICAgIG15ICRuYW1lID0gJGZpZWxkLT5uYW1lOwogICAgICAgICAgICAgICAg +ICAgIGlmKCAkZmllbGQtPmlzYSggIkVQcmludHM6Ok1ldGFGaWVsZDo6TmFtZSIgKSApCiAgICAg +ICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAgICBmb3JlYWNoIG15ICRiaXQg +KCAkZmllbGQtPmdldF9pbnB1dF9iaXRzKCkgKQogICAgICAgICAgICAgICAgICAgICAgICB7CiAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgcHVzaCBAbmFtZXMsJG5hbWUgLiAnLicgLiAkYml0 +OwogICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAg +ICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgICAgICB7ICAgICAgICAgICAgICAgICAg +ICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgIHB1c2ggQG5hbWVzLCBtYXAgewogICAgICAg +ICAgICAgICAgICAgICAgICAgICAgJG5hbWUgLiAnLicgLiAkXy0+e3N1Yl9uYW1lfQogICAgICAg +ICAgICAgICAgICAgICAgICB9IEB7JGZpZWxkLT5wcm9wZXJ0eSgiZmllbGRzX2NhY2hlIil9Owog +ICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIGVs +c2UKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICBwdXNoIEBuYW1lcywgJGZp +ZWxkLT5uYW1lOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgfQogICAg +ICAgIHJldHVybiBAbmFtZXM7CiAgICB9CgogICAgIyBlbHNlIHdlIHVzZSBwaHJhc2VzCiAgICBm +b3JlYWNoIG15ICRmIChAJGZpZWxkcykKICAgIHsKICAgICAgICBpZiggZGVmaW5lZCAkb3B0c3tj +dXN0b21fZXhwb3J0fSAmJiBkZWZpbmVkICRvcHRze2N1c3RvbV9leHBvcnR9LT57JGZ9ICkKICAg +ICAgICB7CiAgICAgICAgICAgIHB1c2ggQG5hbWVzLCAkZHMtPnJlcG9zaXRvcnktPnBocmFzZSgg +ImV4cG9ydGZpZWxkb3B0aW9uczokZiIgKTsKICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAg +IHsKICAgICAgICAgICAgbXkgJGZpZWxkID0gRVByaW50czo6VXRpbHM6OmZpZWxkX2Zyb21fY29u +ZmlnX3N0cmluZyggJGRzLCAkZiApOwoKICAgICAgICAgICAgaWYgKCRmaWVsZC0+aXNhKCJFUHJp +bnRzOjpNZXRhRmllbGQ6Ok11bHRpcGFydCIpKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAg +ICBteSAkcGFyZW50X25hbWUgPSAkZmllbGQtPmRpc3BsYXlfbmFtZSggJGZpZWxkLT5yZXBvc2l0 +b3J5ICk7CiAgICAgICAgICAgICAgICBpZiggJGZpZWxkLT5pc2EoICJFUHJpbnRzOjpNZXRhRmll +bGQ6Ok5hbWUiICkpICMgbmVlZCB0byBkZWFsIHdpdGggbGVnYWN5IHBocmFzZSBpZCdzCiAgICAg +ICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgZm9yZWFjaCBteSAkYml0ICggJGZpZWxk +LT5nZXRfaW5wdXRfYml0cygpICkKICAgICAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAg +ICAgICAgICAgICRiaXQgPSAiZ2l2ZW5fbmFtZXMiIGlmKCAkYml0IGVxICJnaXZlbiIgKTsKICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJGJpdCA9ICJmYW1p +bHlfbmFtZXMiIGlmKCAkYml0IGVxICJmYW1pbHkiICk7CiAgICAgICAgICAgICAgICAgICAgICAg +IG15ICRjdXN0b21fcGhyYXNlID0gJGZpZWxkLT5uYW1lIC4gIl8iIC4gJGJpdDsKICAgICAgICAg +ICAgICAgICAgICAgICAgaWYoICRkcy0+cmVwb3NpdG9yeS0+Z2V0X2xhbmctPmhhc19waHJhc2Uo +ICRjdXN0b21fcGhyYXNlICkgKSAjIGFsbG93IGEgY3VzdG9tIHBocmFzZSB0byBiZSB1c2VkCiAg +ICAgICAgICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHB1c2gg +QG5hbWVzLCAkZHMtPnJlcG9zaXRvcnktPnBocmFzZSggJGN1c3RvbV9waHJhc2UgKTsKICAgICAg +ICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAg +ICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHB1c2ggQG5hbWVz +LCAkcGFyZW50X25hbWUgLiAiOiAiIC4gJGRzLT5yZXBvc2l0b3J5LT5waHJhc2UoICJsaWIvbWV0 +YWZpZWxkOiIuJGJpdCApOwogICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAg +ICAgICAgfQogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgZWxzZQogICAgICAgICAg +ICAgICAgewogICAgICAgICAgICAgICAgICAgIG15ICRuYW1lID0gJGZpZWxkLT5uYW1lOwogICAg +ICAgICAgICAgICAgICAgIHB1c2ggQG5hbWVzLCBtYXAgewogICAgICAgICAgICAgICAgICAgICAg +ICAkbmFtZSAuICcuJyAuICRfLT57c3ViX25hbWV9CiAgICAgICAgICAgICAgICAgICAgfSBAeyRm +aWVsZC0+cHJvcGVydHkoImZpZWxkc19jYWNoZSIpfTsKICAgICAgICAgICAgICAgIH0KICAgICAg +ICAgICAgfQogICAgICAgICAgICBlbHNpZiggJGZpZWxkLT5pc2EoIkVQcmludHM6Ok1ldGFGaWVs +ZDo6Q29tcG91bmQiICkgKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBmb3JlYWNoIG15 +ICRzdWJfZmllbGQgKEB7JGZpZWxkLT5wcm9wZXJ0eSgiZmllbGRzX2NhY2hlIil9KQogICAgICAg +ICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIG15ICRjdXN0b21fcGhyYXNlID0gJGZpZWxk +LT5uYW1lIC4gIl8iIC4gJHN1Yl9maWVsZC0+bmFtZTsKICAgICAgICAgICAgICAgICAgICBpZigg +JGRzLT5yZXBvc2l0b3J5LT5nZXRfbGFuZy0+aGFzX3BocmFzZSggJGN1c3RvbV9waHJhc2UgKSAp +ICMgYWxsb3cgYSBjdXN0b20gcGhyYXNlIHRvIGJlIHVzZWQKICAgICAgICAgICAgICAgICAgICB7 +CiAgICAgICAgICAgICAgICAgICAgICBwdXNoIEBuYW1lcywgJGRzLT5yZXBvc2l0b3J5LT5waHJh +c2UoICRjdXN0b21fcGhyYXNlICk7CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAg +ICAgICAgIGVsc2UKICAgICAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAg +IHB1c2ggQG5hbWVzLCAkZmllbGQtPmRpc3BsYXlfbmFtZSggJGZpZWxkLT5yZXBvc2l0b3J5ICkg +LiAiOiAiIC4gJHN1Yl9maWVsZC0+ZGlzcGxheV9uYW1lKCAkc3ViX2ZpZWxkLT5yZXBvc2l0b3J5 +ICk7CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9 +CiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgcHVzaCBAbmFt +ZXMsICRmaWVsZC0+ZGlzcGxheV9uYW1lKCAkZmllbGQtPnJlcG9zaXRvcnkgKTsKICAgICAgICAg +ICAgfQogICAgICAgIH0KICAgIH0gICAgICAgCiAgICByZXR1cm4gQG5hbWVzOwp9CgpzdWIgZGF0 +YW9ial90b19yb3dzCnsKICAgIG15KCAkc2VsZiwgJGRhdGFvYmosICVvcHRzICkgPSBAXzsKCiAg +ICBteSAkbWFpbl9kYXRhb2JqID0gJGRhdGFvYmo7ICMgc3RvcmUgZGF0YW9iaiBmb3IgZnV0dXJl +IHJlZmVyZW5jZQoKICAgIG15ICRmaWVsZHMgPSAkb3B0c3tmaWVsZHN9IHx8IFskc2VsZi0+Zmll +bGRzKCRkYXRhb2JqLT57ZGF0YXNldH0pXTsKICAgIG15ICRkcyA9ICRvcHRze2xpc3R9LT57ZGF0 +YXNldH07CgogICAgbXkgQHJvd3MgPSAoW10pOwogICAgZm9yZWFjaCBteSAkZm5hbWUgKEAkZmll +bGRzKQogICAgewogICAgICAgICNyZXNldCBkYXRhb2JqIHRvIG1haW4gZGF0YW9iagogICAgICAg +ICRkYXRhb2JqID0gJG1haW5fZGF0YW9iajsKCiAgICAgICAgIyBnZXQgdGhlIGZpZWxkIGZyb20g +dGhlIGlkCiAgICAgICAgbXkgJGZpZWxkOwogICAgICAgIG15IEBmbmFtZXMgPSBzcGxpdCggL1wu +LywgJGZuYW1lICk7CiAgICAgICAgbXkgJHN1Yl9kYXRhb2JqX3ZhbHVlcyA9IFtdOyAgICAgICAg +CiAgICAgICAgaWYoIHNjYWxhciggQGZuYW1lcyA+IDEgKSApICMgYSBmaWVsZCBvZiBhbm90aGVy +IGRhdGFzZXQsIGUuZy4gZG9jdW1lbnRzLmNvbnRlbnQKICAgICAgICAgICAgICAgIHsKICAgICAg +ICAgICAgJGZpZWxkID0gJGRzLT5nZXRfZmllbGQoICRmbmFtZXNbMF0gKTsgIyBmaXJzdCBnZXQg +dGhlIGZpZWxkCiAgICAgICAgICAgIGlmKCAkZmllbGQtPmlzX3R5cGUoICJzdWJvYmplY3QiLCAi +aXRlbXJlZiIgKSApICMgaWYgdGhlIGZpZWxkIGJlbG9uZ3MgdG8gYW5vdGhlciBkYXRhc2V0CiAg +ICAgICAgICAgIHsKICAgICAgICAgICAgICAgIG15ICRzdWJfZHNfaWQgPSAkZmllbGQtPmdldF9w +cm9wZXJ0eSggImRhdGFzZXRpZCIgKTsKICAgICAgICAgICAgICAgIG15ICRtdWx0aXBsZSA9ICRm +aWVsZC0+Z2V0X3Byb3BlcnR5KCAibXVsdGlwbGUiICk7CiAgICAgICAgICAgICAgICBpZiggJG11 +bHRpcGxlICkKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICBteSBAc3ViX2Rh +dGFvYmpzOwogICAgICAgICAgICAgICAgICAgICMgZ2V0IHRoZSBkYXRhb2JqcyBvZiB0aGlzIGZp +ZWxkCiAgICAgICAgICAgICAgICAgICAgaWYoICRzdWJfZHNfaWQgZXEgImRvY3VtZW50IiApICMg +ZG9jdW1lbnRzIHJlcHJlc2VudCBhIHNwZWNpYWwgY2FzZSBvZiBzdWIgb2JqZWN0IC0gd2UgZG9u +J3Qgd2FudCB2b2xhdGlsZSBkb2N1bWVudHMgKHByb2JhYmx5KQogICAgICAgICAgICAgICAgICAg +IHsKICAgICAgICAgICAgICAgICAgICAgICAgQHN1Yl9kYXRhb2JqcyA9ICRkYXRhb2JqLT5nZXRf +YWxsX2RvY3VtZW50czsKICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAg +ZWxzZQogICAgICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAgICAgZm9yZWFj +aCBteSAkc3ViX29iaiAoIEB7JGRhdGFvYmotPnZhbHVlKCAkZm5hbWVzWzBdICl9ICkKICAgICAg +ICAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgcHVzaCBAc3Vi +X2RhdGFvYmpzLCAkZmllbGQtPmdldF9pdGVtKCAkZGF0YW9iai0+cmVwb3NpdG9yeSwgJHN1Yl9v +YmogKTsKICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgIH0KICAg +ICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAjIGFuZCBidWlsZCB1cCBhbiBh +cnJheSBvZiB0aGVzZSBzdWIgZGF0YW9iaidzIHZhbHVlcwogICAgICAgICAgICAgICAgICAgIGZv +cmVhY2ggbXkgJG9iaiAoIEBzdWJfZGF0YW9ianMgKSAjIGdldCB0aGUgdmFsdWVzIHdlIGFyZSBy +ZXF1ZXN0aW5nIG9mIHRoZSBkYXRhb2JqZWN0cwogICAgICAgICAgICAgICAgICAgIHsKICAgICAg +ICAgICAgICAgICAgICAgICAgIyBjaGVjayBmb3IgYSBjdXN0b20gcmVuZGVyZXIKICAgICAgICAg +ICAgICAgICAgICAgICAgbXkgJHZhbHVlOwogICAgICAgICAgICAgICAgICAgICAgICBpZiggZGVm +aW5lZCAkb3B0c3tjdXN0b21fZXhwb3J0fSAmJiBkZWZpbmVkICRvcHRze2N1c3RvbV9leHBvcnR9 +LT57JGZuYW1lfSApCiAgICAgICAgICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICR2YWx1ZSA9ICRvcHRze2N1c3RvbV9leHBvcnR9LT57JGZuYW1lfS0+KCAkb2Jq +LCAkb3B0c3twbHVnaW59ICk7CiAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAg +ICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgICAgICAgICB7ICAgICAgICAgICAgICAg +ICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAkZmllbGQgPSBFUHJpbnRz +OjpVdGlsczo6ZmllbGRfZnJvbV9jb25maWdfc3RyaW5nKCAkb2JqLT5kYXRhc2V0LCAkZm5hbWVz +WzFdICk7ICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAg +ICAgaWYoICRmaWVsZC0+Z2V0X3Byb3BlcnR5KCAidmlydHVhbCIgKSApICMgdmlydHVhbCBmaWVs +ZHMgbmVlZCByZW5kZXJpbmcKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHsKICAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAkdmFsdWUgPSBFUHJpbnRzOjpVdGlsczo6dHJlZV90b191 +dGY4KCAkb2JqLT5yZW5kZXJfdmFsdWUoICRmbmFtZXNbMV0gKSApOwogICAgICAgICAgICAgICAg +ICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICAgICAgICAgZWxzZSAjIHJlZ3VsYXIg +ZmllbGQgdmFsdWVzIGNhbiBzaW1wbHkgYmUgcmV0cmlldmVkCiAgICAgICAgICAgICAgICAgICAg +ICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJHZhbHVlID0gJGZpZWxk +LT5nZXRfdmFsdWUoICRvYmogKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAg +ICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICAgICBwdXNoIEB7JHN1Yl9k +YXRhb2JqX3ZhbHVlc30sICR2YWx1ZTsgCiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAg +ICAgICAgfQogICAgICAgICAgICAgICAgZWxzZSAjIHdlIG9ubHkgaGF2ZSBvbmUgc3ViLW9iamVj +dCwgCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgbXkgJHN1Yl9vYmo7CiAg +ICAgICAgICAgICAgICAgICAgaWYoIHJlZiggJGZpZWxkICkgZXEgIkVQcmludHM6Ok1ldGFGaWVs +ZDo6U3Vib2JqZWN0IiApCiAgICAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAg +ICAgICAkc3ViX29iaiA9ICRkYXRhb2JqLT52YWx1ZSggJGZuYW1lc1swXSApOwogICAgICAgICAg +ICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICBlbHNlICMgZG8gaXQgdGhlIG9yaWdpbmFs +IHdheSAoYXNzdW1pbmcgdGhpcyBldmVyIHdvcmtlZC4uLj8KICAgICAgICAgICAgICAgICAgICB7 +CiAgICAgICAgICAgICAgICAgICAgICAgICRzdWJfb2JqID0gJGZpZWxkLT5nZXRfaXRlbSggJGRh +dGFvYmotPnJlcG9zaXRvcnksICRkYXRhb2JqLT52YWx1ZSggJGZuYW1lc1swXSApICk7ICMgZ2V0 +IHRoZSBzdWJvYmplY3QKICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAg +IAogICAgICAgICAgICAgICAgICAgICRmaWVsZCA9IEVQcmludHM6OlV0aWxzOjpmaWVsZF9mcm9t +X2NvbmZpZ19zdHJpbmcoICRzdWJfb2JqLT5kYXRhc2V0LCAkZm5hbWVzWzFdICk7ICMgZ2V0IHRo +ZSBzdWJvYmplY3RzIGZpZWxkCiAgICAgICAgICAgICAgICAgICAgbXkgJHZhbHVlID0gJGZpZWxk +LT5nZXRfdmFsdWUoICRzdWJfb2JqICk7ICMgZ2V0IHRoZSBzdWJvYmplY3RzIHZhbHVlIGZvciB0 +aGlzIGZpZWxkCiAgICAgICAgICAgICAgICAgICAgcHVzaCBAeyRzdWJfZGF0YW9ial92YWx1ZXN9 +LCAkdmFsdWU7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0KICAgICAgICB9CgogICAg +ICAgIG15ICRpID0gQHskcm93c1swXX07CiAgICAgICAgbXkgJF9yb3dzOwogICAgICAgIGlmKCBF +UHJpbnRzOjpVdGlsczo6aXNfc2V0KCAkZmllbGQgKSApICMgd2UgYWxyZWFkeSBoYXZlIG91ciB2 +YWx1ZXMKICAgICAgICB7CiAgICAgICAgICAgIGlmKCBzY2FsYXIgQHskc3ViX2RhdGFvYmpfdmFs +dWVzfSA+IDAgKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAkX3Jvd3MgPSAkc2VsZi0+ +dmFsdWVfdG9fcm93cygkZmllbGQsICRzdWJfZGF0YW9ial92YWx1ZXMsICRkYXRhb2JqKTsgICAg +ICAgICAgIAogICAgICAgICAgICB9CiAgICAgICAgICAgIGVsc2UgIyB0aGVyZSdzIG5vIHJlc3Vs +dHMsIGJ1dCB3ZSBzdGlsbCBuZWVkIHRvIGFkZCBhbiBlbXB0eSBjZWxsIHRvIHRoZSBzcHJlYWRz +aGVldAogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAkX3Jvd3MgPSAkc2VsZi0+dmFsdWVf +dG9fcm93cygkZmllbGQsIHVuZGVmKTsKICAgICAgICAgICAgfQogICAgICAgIH0KICAgICAgICBl +bHNlICMgd2UgbmVlZCB0byByZXRyaWV2ZSBvdXIgdmFsdWVzIGZvciB0aGlzIGZpZWxkIGZyb20g +b3VyIGRhdGFvYmogKG9yIHN1Yl9kYXRhb2JqKQogICAgICAgIHsKICAgICAgICAgICAgbXkgJHZh +bHVlOwogICAgICAgICAgICBpZiggZGVmaW5lZCAkb3B0c3tjdXN0b21fZXhwb3J0fSAmJiBkZWZp +bmVkICRvcHRze2N1c3RvbV9leHBvcnR9LT57JGZuYW1lfSApICMgd2UgaGF2ZSBhIGN1c3RvbSBl +eHBvcnRlcgogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAkdmFsdWUgPSAkb3B0c3tjdXN0 +b21fZXhwb3J0fS0+eyRmbmFtZX0tPiggJGRhdGFvYmosICRvcHRze3BsdWdpbn0gKTsKICAgICAg +ICAgICAgICAgICRfcm93cyA9ICRzZWxmLT5jdXN0b21fdmFsdWVfdG9fcm93cyggJHZhbHVlICk7 +CiAgICAgICAgICAgIH0KICAgICAgICAgICAgZWxzZSAjIGp1c3QgZ2V0IHRoZSBmaWVsZCdzIHVz +dWFsIHZhbHVlCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICRmaWVsZCA9IEVQcmludHM6 +OlV0aWxzOjpmaWVsZF9mcm9tX2NvbmZpZ19zdHJpbmcoICRkcywgJGZuYW1lICk7CiAgICAgICAg +ICAgICAgICBpZiggJGZpZWxkLT5nZXRfcHJvcGVydHkoICJ2aXJ0dWFsIiApICkgIyB2aXJ0dWFs +IGZpZWxkcyBuZWVkIHJlbmRlcmluZwogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAg +ICAgICR2YWx1ZSA9IEVQcmludHM6OlV0aWxzOjp0cmVlX3RvX3V0ZjgoICRkYXRhb2JqLT5yZW5k +ZXJfdmFsdWUoICRmbmFtZSApICk7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICBl +bHNlICMgcmVndWxhciBmaWVsZCB2YWx1ZXMgY2FuIHNpbXBseSBiZSByZXRyaWV2ZWQKICAgICAg +ICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAkdmFsdWUgPSAkZmllbGQtPmdldF92YWx1 +ZSggJGRhdGFvYmogKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICRfcm93cyA9 +ICRzZWxmLT52YWx1ZV90b19yb3dzKCRmaWVsZCwgJHZhbHVlLCAkZGF0YW9iaik7ICAgICAgICAK +ICAgICAgICAgICAgfSAgICAgICAgICAgCiAgICAgICAgfQoKICAgICAgICBmb3JlYWNoIG15ICRq +ICgwLi4kIyRfcm93cykKICAgICAgICB7CiAgICAgICAgICAgIGZvcmVhY2ggbXkgJF9pICgwLi4k +I3skX3Jvd3MtPlskal19KQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAkcm93c1skal1b +JGkrJF9pXSA9ICRfcm93cy0+WyRqXVskX2ldOwogICAgICAgICAgICB9CiAgICAgICAgfQogICAg +fQoKICAgICMgZ2VuZXJhdGUgY29tcGxldGUgcm93cwogICAgaWYoJG9wdHN7cGx1Z2lufS0+cGFy +YW0oICJtdWx0aWxpbmVfcmVwZWF0IiApKSAjIHdlIHdhbnQgZWFjaCBjb2x1bW4gdG8gcmVwZWF0 +IGZvciBlYWNoIHJvdwogICAgewogICAgICAgIGZvcmVhY2ggbXkgJGkgKDAuLihzY2FsYXIgQHJv +d3MpLTEpCiAgICAgICAgewogICAgICAgICAgICBmb3JlYWNoIG15ICRqICgwLi4kI3skcm93c1sw +XX0pCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICRyb3dzWyRpXVskal0gfHw9ICRyb3dz +WzBdWyRqXTsKICAgICAgICAgICAgfSAgIAogICAgICAgIH0KICAgIH0KICAgIGVsc2UgIyB3ZSBk +b24ndCB3YW50IHJlcGVhdGluZyB2YWx1ZXMgaW4gdGhlIGNvbHVtbnMKICAgIHsgICAKICAgICAg +ICBmb3IoQHJvd3MpIHsKICAgICAgICAgICAgJF8tPlswXSA9ICRyb3dzWzBdWzBdOyAjIGZpcnN0 +IGVsZW1lbnQgb2YgdGhpcyBhcnJheSBlcXVhbHMgdGhlIGZpcnN0IGVsZW1lbnQgb2YgdGhlIGZp +cnN0IHJvdwogICAgICAgICAgICAkXy0+WyQjeyRyb3dzWzBdfV0gfHw9IHVuZGVmOwogICAgICAg +IH0KCiAgICB9CgogICAgcmV0dXJuIFxAcm93czsKfQoKc3ViIHZhbHVlX3RvX3Jvd3MKewogICAg +bXkgKCRzZWxmLCAkZmllbGQsICR2YWx1ZSwgJGRhdGFvYmopID0gQF87CgogICAgbXkgQHJvd3M7 +CgogICAgaWYgKHJlZigkdmFsdWUpIGVxICJBUlJBWSIpCiAgICB7CiAgICAgICAgJHZhbHVlID0g +WyRmaWVsZC0+ZW1wdHlfdmFsdWVdIGlmICFAJHZhbHVlOwogICAgICAgIEByb3dzID0gbWFwIHsg +JHNlbGYtPnZhbHVlX3RvX3Jvd3MoJGZpZWxkLCAkXywgJGRhdGFvYmopLT5bMF0gfSBAJHZhbHVl +OwogICAgfQogICAgZWxzaWYgKCRmaWVsZC0+aXNhKCJFUHJpbnRzOjpNZXRhRmllbGQ6Ok11bHRp +cGFydCIpKQogICAgewogICAgICAgIGlmKCAkZmllbGQtPmlzYSggIkVQcmludHM6Ok1ldGFGaWVs +ZDo6TmFtZSIgKSkgIyBuZWVkIHRvIGRlYWwgd2l0aCBsZWdhY3kgcGhyYXNlIGlkJ3MKICAgICAg +ICB7CiAgICAgICAgICAgIG15IEBiaXRfdmFsdWVzOwogICAgICAgICAgICBmb3JlYWNoIG15ICRi +aXQgKCAkZmllbGQtPmdldF9pbnB1dF9iaXRzKCkgKQogICAgICAgICAgICB7CiAgICAgICAgICAg +ICAgICBwdXNoIEBiaXRfdmFsdWVzLCAkdmFsdWUtPnskYml0fTsKICAgICAgICAgICAgfSAgIAog +ICAgICAgICAgICBwdXNoIEByb3dzLCBcQGJpdF92YWx1ZXM7CiAgICAgICAgfQogICAgICAgIGVs +c2UKICAgICAgICB7CiAgICAgICAgICAgIHB1c2ggQHJvd3MsIFttYXAgeyAkdmFsdWUtPnskXy0+ +e3N1Yl9uYW1lfX0gfSBAeyRmaWVsZC0+cHJvcGVydHkoImZpZWxkc19jYWNoZSIpfV07CiAgICAg +ICAgfQogICAgfQogICAgZWxzaWYgKCRmaWVsZC0+aXNhKCJFUHJpbnRzOjpNZXRhRmllbGQ6OkNv +bXBvdW5kIikpCiAgICB7CiAgICAgICAgbXkgQHN1Yl92YWx1ZXM7CiAgICAgICAgZm9yZWFjaCBt +eSAka2V5IChrZXlzICV7JHZhbHVlfSkKICAgICAgICB7CiAgICAgICAgICAgIHB1c2ggQHN1Yl92 +YWx1ZXMsICR2YWx1ZS0+eyRrZXl9OwogICAgICAgIH0KICAgICAgICBwdXNoIEByb3dzLCBcQHN1 +Yl92YWx1ZXM7CiAgICB9CiAgICBlbHNpZiggJGZpZWxkLT5pc2EoIkVQcmludHM6Ok1ldGFGaWVs +ZDo6U3ViamVjdCIpKQogICAgewogICAgICAgIGlmKCAkdmFsdWUgbmUgIiIgKQogICAgICAgIHsK +ICAgICAgICAgICAgcHVzaCBAcm93cywgW0VQcmludHM6OlV0aWxzOjp0cmVlX3RvX3V0ZjgoICRm +aWVsZC0+cmVuZGVyX3NpbmdsZV92YWx1ZSggJGZpZWxkLT5yZXBvc2l0b3J5LCAkdmFsdWUgKSAp +XTsKICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAgIHsKICAgICAgICAgICAgcHVzaCBAcm93 +cywgWyR2YWx1ZV07CiAgICAgICAgfQogICAgfQogICAgZWxzaWYoICEkZmllbGQtPmlzYSgiRVBy +aW50czo6TWV0YUZpZWxkOjpTdWJvYmplY3QiKSAmJiAkZmllbGQtPmlzX3ZpcnR1YWwgKQogICAg +ewogICAgICAgICNwdXNoIEByb3dzLCBbJGRhdGFvYmotPnJlbmRlcl92YWx1ZSggJGZpZWxkLT5u +YW1lICldOwogICAgICAgIHB1c2ggQHJvd3MsIFskdmFsdWVdOwogICAgfQogICAgZWxzZQogICAg +ewogICAgICAgIHB1c2ggQHJvd3MsIFskdmFsdWVdOwogICAgfQoKICAgIHJldHVybiBcQHJvd3M7 +Cn0KCiMgdXNlZCBmb3IgY3VzdG9tIGV4cG9ydHMgdGhhdCBtaWdodCByZXR1cm4gYSBmaWVsZCBv +ciBhbiBhcnJheSAoYnV0IGFyZW4ndCBuZWNlc2FyaWx5IGFzc29jaWF0ZWQgd2l0aCBhIGZpZWxk +ISkKc3ViIGN1c3RvbV92YWx1ZV90b19yb3dzCnsKICAgIG15ICgkc2VsZiwgJHZhbHVlKSA9IEBf +OwoKICAgIG15IEByb3dzOwoKICAgIGlmIChyZWYoJHZhbHVlKSBlcSAiQVJSQVkiKQogICAgewog +ICAgICAgIEByb3dzID0gbWFwIHsgJHNlbGYtPmN1c3RvbV92YWx1ZV90b19yb3dzKCRfKS0+WzBd +IH0gQCR2YWx1ZTsKICAgIH0KICAgIGVsc2UKICAgIHsKICAgICAgICBwdXNoIEByb3dzLCBbJHZh +bHVlXTsKICAgIH0KCiAgICByZXR1cm4gXEByb3dzOwp9CgoKMTsKCj1oZWFkMSBDT1BZUklHSFQK +Cj1mb3IgQ09QWVJJR0hUIEJFR0lOCgpDb3B5cmlnaHQgMjAwMC0yMDExIFVuaXZlcnNpdHkgb2Yg +U291dGhhbXB0b24uCgo9Zm9yIENPUFlSSUdIVCBFTkQKCj1mb3IgTElDRU5TRSBCRUdJTgoKVGhp +cyBmaWxlIGlzIHBhcnQgb2YgRVByaW50cyBMPGh0dHA6Ly93d3cuZXByaW50cy5vcmcvPi4KCkVQ +cmludHMgaXMgZnJlZSBzb2Z0d2FyZTogeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1v +ZGlmeSBpdAp1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMg +TGljZW5zZSBhcyBwdWJsaXNoZWQKYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgZWl0 +aGVyIHZlcnNpb24gMyBvZiB0aGUgTGljZW5zZSwgb3IKKGF0IHlvdXIgb3B0aW9uKSBhbnkgbGF0 +ZXIgdmVyc2lvbi4KCkVQcmludHMgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3 +aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQKQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhl +IGltcGxpZWQgd2FycmFudHkgb2YgTUVSQ0hBTlRBQklMSVRZIG9yCkZJVE5FU1MgRk9SIEEgUEFS +VElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUgTGVzc2VyIEdlbmVyYWwgUHVibGljCkxpY2Vu +c2UgZm9yIG1vcmUgZGV0YWlscy4KCllvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2Yg +dGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKTGljZW5zZSBhbG9uZyB3aXRoIEVQcmludHMu +ICBJZiBub3QsIHNlZSBMPGh0dHA6Ly93d3cuZ251Lm9yZy9saWNlbnNlcy8+LgoKPWZvciBMSUNF +TlNFIEVORAoK + document plugins/EPrints/Plugin/Export/MultilineCSV2.pm text/plain ece09c3f7932a096c5cf14b6165a579d @@ -424,6 +497,7 @@ c2VlIEw8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uCgo9Zm9yIExJQ0VOU0UgRU5ECgo= + document plugins/EPrints/Plugin/Export/Report.pm text/plain 4532f1d3111eede3fe6a4e8c66965895 @@ -477,11 +551,12 @@ ZGF0YW9iai0+ZGF0YXNldC0+Y29uZmlkID0+ICRkYXRhb2JqLAoJfTsKfQoKMTsK + document plugins/EPrints/Plugin/Export/Report/CSV.pm text/plain - 9ca03f1aa33ed8390c18f29c2ed96d16 + 197a1e34988fac693a4f2825cfc823d0 MD5 - 1785 + 2084 cGFja2FnZSBFUHJpbnRzOjpQbHVnaW46OkV4cG9ydDo6UmVwb3J0OjpDU1Y7Cgp1c2UgRVByaW50 czo6UGx1Z2luOjpFeHBvcnQ6OlJlcG9ydDsKQElTQSA9ICggIkVQcmludHM6OlBsdWdpbjo6RXhw b3J0OjpSZXBvcnQiICk7Cgp1c2Ugc3RyaWN0OwoKc3ViIG5ldwp7CglteSggJGNsYXNzLCAlcGFy @@ -489,34 +564,40 @@ YW1zICkgPSBAXzsKCglteSAkc2VsZiA9ICRjbGFzcy0+U1VQRVI6Om5ldyggJXBhcmFtcyApOwoK CSRzZWxmLT57bmFtZX0gPSAiR2VuZXJpYyBDU1YiOwoJJHNlbGYtPntzdWZmaXh9ID0gIi5jc3Yi OwoJJHNlbGYtPnttaW1ldHlwZX0gPSAidGV4dC9wbGFpbjsgY2hhcnNldD11dGYtOCI7Cgkkc2Vs Zi0+e2FjY2VwdH0gPSBbICdyZXBvcnQvZ2VuZXJpYycgXTsKCSRzZWxmLT57YWR2ZXJ0aXNlfSA9 -IDE7CgoJcmV0dXJuICRzZWxmOwp9CgpzdWIgb3V0cHV0X2xpc3QKewogICAgICAgIG15KCAkcGx1 -Z2luLCAlb3B0cyApID0gQF87ICAgICAKCglteSAkcmVwbyA9ICRwbHVnaW4tPnJlcG9zaXRvcnk7 -CgoJJHBsdWdpbi0+Z2V0X2V4cG9ydF9maWVsZHMoICVvcHRzICk7ICNnZXQgZXhwb3J0IGZpZWxk -cyBiYXNlZCBvbiB1c2VyIHJlcXVpcmVtZW50cyBvciBwbHVnaW4gZGVmYXVsdHMKCglpZiggZGVm -aW5lZCAkcGx1Z2luLT57Y3VzdG9tX2ZpZWxkc30gKSAjdGhlIHNjcmVlbiBoYXMgZGVmaW5lZCBl -eHBvcnQgZmllbGRzCgl7CgkJJG9wdHN7ZmllbGRzfSA9ICRwbHVnaW4tPntleHBvcnRmaWVsZHN9 -OwoJfQoKCSNzZXQgYW55IGN1c3RvbSBleHBvcnQgZnVuY3Rpb25zCgkkb3B0c3tjdXN0b21fZXhw -b3J0fSA9ICRyZXBvLT5jb25maWcoICRwbHVnaW4tPntyZXBvcnR9LT57ZXhwb3J0X2NvbmZ9LCAi -Y3VzdG9tX2V4cG9ydCIgKTsKCgkjbm93IHVzZSB0aGUgZ2VuZXJpYyBtdWx0aWxpbmUgY3N2IHBs -dWdpbiB0byBoYW5kbGUgdGhlIGV4cG9ydAoJbXkgJG11bHRpbGluZV9jc3YgPSBFUHJpbnRzOjpQ -bHVnaW46OkV4cG9ydDo6TXVsdGlsaW5lQ1NWMi0+bmV3KCAlb3B0cyApOwoJJG11bHRpbGluZV9j -c3YtPm91dHB1dF9saXN0KCAlb3B0cyApOyAKfQoKI3JldGFpbmVkIGZvciBsZWdhY3kgcmVhc29u -cyAtIGV4dGVuc2lvbnMgb2YgRXhwb3J0OjpSZXBvcnQ6OkNTViBtYXkgdXNlIHRoaXMKc3ViIGVz -Y2FwZV92YWx1ZQp7CiAgICAgICAgbXkoICRwbHVnaW4sICR2YWx1ZSApID0gQF87CgogICAgICAg -IHJldHVybiAnIiInIHVubGVzcyggZGVmaW5lZCBFUHJpbnRzOjpVdGlsczo6aXNfc2V0KCAkdmFs -dWUgKSApOwoKICAgICAgICAjIHN0cmlwcyBhbnkga2luZCBvZiBkb3VibGUtcXVvdGVzOgogICAg -ICAgICR2YWx1ZSA9fiBzL1x4OTN8XHg5NHwiLycvZzsKICAgICAgICAjIGFuZCBjb250cm9sLWNo -YXJhY3RlcnMKICAgICAgICAkdmFsdWUgPX4gcy9cbnxccnxcdC8vZzsKICAgICAgICAKCSMgaWYg -dmFsdWUgaXMgYSBwdXJlIG51bWJlciwgdGhlbiBhZGQgPSIkdmFsdWUiIHNvIHRoYXQgRXhjZWwg -c3RvcHMgdGhlIGF1dG8tZm9ybWF0dGluZyAoaXQnZCB0dXJuIDEyMzQ1NiBpbnRvIDEuMjNlKzYp -CglpZiggJHZhbHVlID1+IC9eWzAtOVwtXSskLyApCiAgICAgICAgewoJCXJldHVybiAiPVwiJHZh -bHVlXCIiOwogICAgICAgIH0KICAgICAgICAKICAgICAgICAjIG9ubHkgZXNjYXBlcyByb3cgd2l0 -aCBzcGFjZXMgYW5kIGNvbW1hcwogICAgICAgIGlmKCAkdmFsdWUgPX4gLyx8IC8gKQogICAgICAg -IHsKICAgICAgICAJcmV0dXJuICJcIiR2YWx1ZVwiIjsKCX0KICAgICAgIAkKCXJldHVybiAkdmFs -dWU7Cn0KCjE7ICAgICAgICAK +IDE7CgoJcmV0dXJuICRzZWxmOwp9CgpzdWIgaW5pdGlhbGlzZV9maAp7CiAgICBteSggJHBsdWdp +biwgJGZoICkgPSBAXzsKCiAgICAkcGx1Z2luLT5TVVBFUjo6aW5pdGlhbGlzZV9maCggJGZoICk7 +CgogICAgIyBpbmNsdWRlIFVURi04IGJ5dGUgb3JkZXIgbWFya2VyIHNvIEV4Y2VsIGtub3dzIGhv +dyB0byBkaXNwbGF5IHRoZSBjb250ZW4KICAgIG15ICRyZXBvID0gJHBsdWdpbi0+cmVwb3NpdG9y +eTsKICAgIGlmKCAkcmVwby0+Y29uZmlnKCAicmVwb3J0cyIsICJjc3ZfdXRmOF9ib20iICkgKQog +ICAgewogICAgICAgIHByaW50ICRmaCBjaHIoNjUyNzkpOwogICAgfQp9CgpzdWIgb3V0cHV0X2xp +c3QKewoJbXkoICRwbHVnaW4sICVvcHRzICkgPSBAXzsgICAgIAoKCW15ICRyZXBvID0gJHBsdWdp +bi0+cmVwb3NpdG9yeTsKCgkkcGx1Z2luLT5nZXRfZXhwb3J0X2ZpZWxkcyggJW9wdHMgKTsgI2dl +dCBleHBvcnQgZmllbGRzIGJhc2VkIG9uIHVzZXIgcmVxdWlyZW1lbnRzIG9yIHBsdWdpbiBkZWZh +dWx0cwoKCWlmKCBkZWZpbmVkICRwbHVnaW4tPntjdXN0b21fZmllbGRzfSApICN0aGUgc2NyZWVu +IGhhcyBkZWZpbmVkIGV4cG9ydCBmaWVsZHMKCXsKCQkkb3B0c3tmaWVsZHN9ID0gJHBsdWdpbi0+ +e2V4cG9ydGZpZWxkc307Cgl9CgoJI3NldCBhbnkgY3VzdG9tIGV4cG9ydCBmdW5jdGlvbnMKCSRv +cHRze2N1c3RvbV9leHBvcnR9ID0gJHJlcG8tPmNvbmZpZyggJHBsdWdpbi0+e3JlcG9ydH0tPntl +eHBvcnRfY29uZn0sICJjdXN0b21fZXhwb3J0IiApOwoKCSNub3cgdXNlIHRoZSBnZW5lcmljIG11 +bHRpbGluZSBjc3YgcGx1Z2luIHRvIGhhbmRsZSB0aGUgZXhwb3J0CglteSAkbXVsdGlsaW5lX2Nz +diA9IEVQcmludHM6OlBsdWdpbjo6RXhwb3J0OjpNdWx0aWxpbmVDU1YyLT5uZXcoICVvcHRzICk7 +CgkkbXVsdGlsaW5lX2Nzdi0+b3V0cHV0X2xpc3QoICVvcHRzICk7IAp9CgojcmV0YWluZWQgZm9y +IGxlZ2FjeSByZWFzb25zIC0gZXh0ZW5zaW9ucyBvZiBFeHBvcnQ6OlJlcG9ydDo6Q1NWIG1heSB1 +c2UgdGhpcwpzdWIgZXNjYXBlX3ZhbHVlCnsKICAgICAgICBteSggJHBsdWdpbiwgJHZhbHVlICkg +PSBAXzsKCiAgICAgICAgcmV0dXJuICciIicgdW5sZXNzKCBkZWZpbmVkIEVQcmludHM6OlV0aWxz +Ojppc19zZXQoICR2YWx1ZSApICk7CgogICAgICAgICMgc3RyaXBzIGFueSBraW5kIG9mIGRvdWJs +ZS1xdW90ZXM6CiAgICAgICAgJHZhbHVlID1+IHMvXHg5M3xceDk0fCIvJy9nOwogICAgICAgICMg +YW5kIGNvbnRyb2wtY2hhcmFjdGVycwogICAgICAgICR2YWx1ZSA9fiBzL1xufFxyfFx0Ly9nOwog +ICAgICAgIAoJIyBpZiB2YWx1ZSBpcyBhIHB1cmUgbnVtYmVyLCB0aGVuIGFkZCA9IiR2YWx1ZSIg +c28gdGhhdCBFeGNlbCBzdG9wcyB0aGUgYXV0by1mb3JtYXR0aW5nIChpdCdkIHR1cm4gMTIzNDU2 +IGludG8gMS4yM2UrNikKCWlmKCAkdmFsdWUgPX4gL15bMC05XC1dKyQvICkKICAgICAgICB7CgkJ +cmV0dXJuICI9XCIkdmFsdWVcIiI7CiAgICAgICAgfQogICAgICAgIAogICAgICAgICMgb25seSBl +c2NhcGVzIHJvdyB3aXRoIHNwYWNlcyBhbmQgY29tbWFzCiAgICAgICAgaWYoICR2YWx1ZSA9fiAv +LHwgLyApCiAgICAgICAgewogICAgICAgIAlyZXR1cm4gIlwiJHZhbHVlXCIiOwoJfQogICAgICAg +CQoJcmV0dXJuICR2YWx1ZTsKfQoKMTsgICAgICAgIAo= + document plugins/EPrints/Plugin/Export/Report/CSV/Example.pm text/plain 0e433b1b61f549da00316e4971512570 @@ -533,6 +614,7 @@ ZjsKfQoKCjE7Cg== + document plugins/EPrints/Plugin/Export/Report/HTML.pm text/plain 8e2ca840f2fd1fa5983bcca0f96a7233 @@ -639,11 +721,12 @@ dGF0aW9uX2xpbmsgKTsKCiAgICAgICAgcmV0dXJuICRwOwp9CgoxOyAgICAgICAgCg== + document plugins/EPrints/Plugin/Export/Report/JSON.pm text/plain - 3786d272e437a488408e5825270e1609 + c4b031c985ca0de7c8263474b232be14 MD5 - 6648 + 6994 cGFja2FnZSBFUHJpbnRzOjpQbHVnaW46OkV4cG9ydDo6UmVwb3J0OjpKU09OOwoKdXNlIEVQcmlu dHM6OlBsdWdpbjo6RXhwb3J0OjpSZXBvcnQ7CkBJU0EgPSAoICJFUHJpbnRzOjpQbHVnaW46OkV4 cG9ydDo6UmVwb3J0IiApOwoKdXNlIHN0cmljdDsKCnN1YiBuZXcKewoJbXkoICRjbGFzcywgJXBh @@ -713,62 +796,69 @@ ICAgICAgICAgICAgICAgICAgICAgJGVwZGF0YS0+aXNhKCAiRVByaW50czo6RGF0YU9iajo6RG9j dW1lbnQiICkgJiYKICAgICAgICAgICAgICAgICAgICAgICAgJGVwZGF0YS0+aGFzX3JlbGF0aW9u KCB1bmRlZiwgImlzVm9sYXRpbGVWZXJzaW9uT2YiICkKICAgICAgICAgICAgICAgICAgKTsKCiAg ICAgICAgICAgICAgICBmb3JlYWNoIG15ICRmaWVsZG5hbWUgKCBAeyRzZWxmLT57ZXhwb3J0Zmll -bGRzfX0gKQogICAgICAgICAgICAgICAgewoJCQlteSBAZm5hbWVzID0gc3BsaXQoIC9cLi8sICRm -aWVsZG5hbWUgKTsKICAgICAgICAgICAgICAgICAgICAgICAgaWYoIHNjYWxhciggQGZuYW1lcyA+ -IDEgKSApICNhIGZpZWxkIG9mIGFub3RoZXIgZGF0YXNldCwgZS5nLiBkb2N1bWVudHMuY29udGVu -dAogICAgICAgICAgICAgICAgICAgICAgICB7CgkJCQlteSAkZmllbGQgPSAkc2VsZi0+e2RhdGFz -ZXR9LT5nZXRfZmllbGQoICRmbmFtZXNbMF0gKTsgI2ZpcnN0IGdldCB0aGUgZmllbGQKICAgICAg -ICAgICAgICAgICAgICAgICAgICAgICAgICBpZiggJGZpZWxkLT5pc190eXBlKCAic3Vib2JqZWN0 -IiwgIml0ZW1yZWYiICkgKSAjaWYgdGhlZSBmaWVsZCBiZWxvbmdzIHRvIGFub3RoZXIgZGF0YXNl -dAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHsKCQkJCQlteSAkc3Vic3ViZGF0YSA9 -ICRzdWJkYXRhLT57JGZuYW1lc1swXX0gfHwgW107ICNjcmVhdGUgYW4gYXJyYXkgZm9yIHRoZSBz -dWIgb2plY3RzCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCW15ICRkYXRhb2Jqcz0g -JGVwZGF0YS0+dmFsdWUoICRmbmFtZXNbMF0gKTsgI2dldCB0aGUgZGF0YW9iamVjdHMgdGhpcyBm -aWVsZCByZXByZXNlbnRzCgkJCQkJZm9yIChteSAkaT0wOyAkaSA8IHNjYWxhciggQHskZGF0YW9i -anN9ICk7ICRpKyspCgkJCQkJewoJCQkJCQlteSAkb2JqID0gQHskZGF0YW9ianN9WyRpXTsgI2dl -dCB0aGUgdmFsdWUgZnJvbSB0aGUgZGF0YW9iamVjdAkJCQoJCQkJCQlteSAkdmFsdWUgPSAkb2Jq -LT52YWx1ZSggJGZuYW1lc1sxXSApOwoJCQkJCQluZXh0IGlmICFFUHJpbnRzOjpVdGlsczo6aXNf -c2V0KCAkdmFsdWUgKTsKCgkJCQkJCW15ICRzdWJzdWJzdWJkYXRhID0gJHN1YmRhdGEtPnskZm5h -bWVzWzBdfVskaV0gfHwge307CgkJCQkJCSRzdWJzdWJzdWJkYXRhLT57JGZuYW1lc1sxXX0gPSAk -dmFsdWU7CQkKCgkJCQkJCSRzdWJkYXRhLT57JGZuYW1lc1swXX1bJGldID0gJHN1YnN1YnN1YmRh -dGE7CQkJCQkKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0gICAgICAg -ICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAg -ICAgfQoJCQl9CgkJCWVsc2UKCQkJewoJCQkJbXkgJGZpZWxkID0gJHNlbGYtPntkYXRhc2V0fS0+ -Z2V0X2ZpZWxkKCAkZmllbGRuYW1lICk7CgkgICAgICAgICAgICAgICAgICAgICAgICBuZXh0IGlm -ICEkZmllbGQtPmdldF9wcm9wZXJ0eSggImV4cG9ydF9hc194bWwiICk7CiAgICAgICAgCSAgICAg -ICAgICAgICAgICBuZXh0IGlmIGRlZmluZWQgJGZpZWxkLT57c3ViX25hbWV9OwoJCQkJbXkgJHZh -bHVlID0gJGZpZWxkLT5nZXRfdmFsdWUoICRlcGRhdGEgKTsKCQkJCWlmKCBkZWZpbmVkICRyZXBv -LT5jb25maWcoICRzZWxmLT57cmVwb3J0fS0+e2V4cG9ydF9jb25mfSwgImN1c3RvbV9leHBvcnQi -ICkgJiYKCQkJCQlleGlzdHMgJHJlcG8tPmNvbmZpZyggJHNlbGYtPntyZXBvcnR9LT57ZXhwb3J0 -X2NvbmZ9LCAiY3VzdG9tX2V4cG9ydCIgKS0+eyRmaWVsZC0+Z2V0X25hbWV9ICkKICAgICAgICAJ -ICAgICAgICAgICAgICAgIHsKCQkJCQkkdmFsdWUgPSAkcmVwby0+Y29uZmlnKCAkc2VsZi0+e3Jl -cG9ydH0tPntleHBvcnRfY29uZn0sICJjdXN0b21fZXhwb3J0IiApLT57JGZpZWxkLT5nZXRfbmFt -ZX0tPiggJGVwZGF0YSwgJHNlbGYtPntyZXBvcnR9ICk7CgkJCQl9CgkJCQlpZiggZGVmaW5lZCAk -ZmllbGQtPnt2aXJ0dWFsfSApCgkJCQl7CgkJCQkJJHZhbHVlID0gRVByaW50czo6VXRpbHM6OnRy -ZWVfdG9fdXRmOCggJGVwZGF0YS0+cmVuZGVyX3ZhbHVlKCAkZmllbGQtPmdldF9uYW1lICkgKTsK -CQkJCX0KCQkgICAgICAgICAgICAgICAgbmV4dCBpZiAhRVByaW50czo6VXRpbHM6OmlzX3NldCgg -JHZhbHVlICk7CiAgICAgICAgCSAgICAgICAgICAgICAgICAkc3ViZGF0YS0+eyRmaWVsZC0+Z2V0 -X25hbWV9ID0gJHZhbHVlOwoJCQl9CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAk -c3ViZGF0YS0+e3VyaX0gPSAkZXBkYXRhLT51cmk7CgogICAgICAgICAgICAgICAgcmV0dXJuICRz -ZWxmLT5fZXBkYXRhX3RvX2pzb24oICRzdWJkYXRhLCAkZGVwdGggKyAxLCAwLCAlb3B0cyApOwog -ICAgICAgIH0KfQoKCnN1YiBlc2NhcGVfdmFsdWUKewoJbXkoICRwbHVnaW4sICR2YWx1ZSApID0g -QF87CgoJcmV0dXJuICciIicgdW5sZXNzKCBkZWZpbmVkIEVQcmludHM6OlV0aWxzOjppc19zZXQo -ICR2YWx1ZSApICk7CgoJIyBzdHJpcHMgYW55IGtpbmQgb2YgZG91YmxlLXF1b3RlczoKCSR2YWx1 -ZSA9fiBzL1x4OTN8XHg5NHwiLycvZzsKCSMgYW5kIGNvbnRyb2wtY2hhcmFjdGVycwoJJHZhbHVl -ID1+IHMvXG58XHJ8XHQvL2c7CgoJIyBpZiB2YWx1ZSBpcyBhIHB1cmUgbnVtYmVyLCB0aGVuIGFk -ZCA9IiR2YWx1ZSIgc28gdGhhdCBFeGNlbCBzdG9wcyB0aGUgYXV0by1mb3JtYXR0aW5nIChpdCdk -IHR1cm4gMTIzNDU2IGludG8gMS4yM2UrNikKCWlmKCAkdmFsdWUgPX4gL15bMC05XC1dKyQvICkK -CXsKCQlyZXR1cm4gIj1cIiR2YWx1ZVwiIjsKCX0KCgkjIG9ubHkgZXNjYXBlcyByb3cgd2l0aCBz -cGFjZXMgYW5kIGNvbW1hcwoJaWYoICR2YWx1ZSA9fiAvLHwgLyApCgl7CgkJcmV0dXJuICJcIiR2 -YWx1ZVwiIjsKCX0KCglyZXR1cm4gJHZhbHVlOwp9CgoKMTsK +bGRzfX0gKQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIG15IEBmbmFtZXMg +PSBzcGxpdCggL1wuLywgJGZpZWxkbmFtZSApOwogICAgICAgICAgICAgICAgICAgIGlmKCBzY2Fs +YXIoIEBmbmFtZXMgPiAxICkgKSAjYSBmaWVsZCBvZiBhbm90aGVyIGRhdGFzZXQsIGUuZy4gZG9j +dW1lbnRzLmNvbnRlbnQKICAgICAgICAgICAgICAgICAgICB7CgkJCQkgICAgICAgIG15ICRmaWVs +ZCA9ICRzZWxmLT57ZGF0YXNldH0tPmdldF9maWVsZCggJGZuYW1lc1swXSApOyAjZmlyc3QgZ2V0 +IHRoZSBmaWVsZAogICAgICAgICAgICAgICAgICAgICAgICBpZiggJGZpZWxkLT5pc190eXBlKCAi +c3Vib2JqZWN0IiwgIml0ZW1yZWYiICkgKSAjaWYgdGhlZSBmaWVsZCBiZWxvbmdzIHRvIGFub3Ro +ZXIgZGF0YXNldAogICAgICAgICAgICAgICAgICAgICAgICB7CgkJCQkJICAgICAgICBteSAkc3Vi +c3ViZGF0YSA9ICRzdWJkYXRhLT57JGZuYW1lc1swXX0gfHwgW107ICNjcmVhdGUgYW4gYXJyYXkg +Zm9yIHRoZSBzdWIgb2plY3RzCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBteSAkZGF0YW9i +anM9ICRlcGRhdGEtPnZhbHVlKCAkZm5hbWVzWzBdICk7ICNnZXQgdGhlIGRhdGFvYmplY3RzIHRo +aXMgZmllbGQgcmVwcmVzZW50cwoJCQkJCSAgICAgICAgZm9yIChteSAkaT0wOyAkaSA8IHNjYWxh +ciggQHskZGF0YW9ianN9ICk7ICRpKyspCgkJCQkJICAgICAgICB7CgkJCQkJCSAgICAgICAgbXkg +JG9iaiA9IEB7JGRhdGFvYmpzfVskaV07ICNnZXQgdGhlIHZhbHVlIGZyb20gdGhlIGRhdGFvYmpl +Y3QJCQkKCQkJCQkJICAgICAgICBteSAkdmFsdWUgPSAkb2JqLT52YWx1ZSggJGZuYW1lc1sxXSAp +OwoJCQkJCQkgICAgICAgIG5leHQgaWYgIUVQcmludHM6OlV0aWxzOjppc19zZXQoICR2YWx1ZSAp +OwoKCQkJCQkJICAgICAgICBteSAkc3Vic3Vic3ViZGF0YSA9ICRzdWJkYXRhLT57JGZuYW1lc1sw +XX1bJGldIHx8IHt9OwoJCQkJCQkgICAgICAgICRzdWJzdWJzdWJkYXRhLT57JGZuYW1lc1sxXX0g +PSAkdmFsdWU7CQkKCgkJCQkJCSAgICAgICAgJHN1YmRhdGEtPnskZm5hbWVzWzBdfVskaV0gPSAk +c3Vic3Vic3ViZGF0YTsJCQkJCQogICAgICAgICAgICAgICAgICAgICAgICAgICAgfSAgICAgICAg +ICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgIH0KCQkJ +ICAgICAgICB9CgkJCSAgICAgICAgZWxzZQoJCQkgICAgICAgIHsKICAgICAgICAgICAgICAgICAg +ICAgICAgaWYoIGRlZmluZWQgJHJlcG8tPmNvbmZpZyggJHNlbGYtPntyZXBvcnR9LT57ZXhwb3J0 +X2NvbmZ9LCAiY3VzdG9tX2V4cG9ydCIgKSAmJgoJCQkJCSAgICAgICAgZXhpc3RzICRyZXBvLT5j +b25maWcoICRzZWxmLT57cmVwb3J0fS0+e2V4cG9ydF9jb25mfSwgImN1c3RvbV9leHBvcnQiICkt +PnskZmllbGRuYW1lfSApCiAgICAgICAgCSAgICAgICAgICAgIHsKCQkJCQkgICAgICAgIG15ICR2 +YWx1ZSA9ICRyZXBvLT5jb25maWcoICRzZWxmLT57cmVwb3J0fS0+e2V4cG9ydF9jb25mfSwgImN1 +c3RvbV9leHBvcnQiICktPnskZmllbGRuYW1lfS0+KCAkZXBkYXRhLCAkc2VsZi0+e3JlcG9ydH0g +KTsKCSAgICAgICAJICAgICAgICAgICAgICAgICRzdWJkYXRhLT57JGZpZWxkbmFtZX0gPSAkdmFs +dWU7CQkgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAg +ICAgICAgIGVsc2UKICAgICAgICAgICAgICAgICAgICAgICAgewoJCQkJICAgICAgICAgICAgbXkg +JGZpZWxkID0gJHNlbGYtPntkYXRhc2V0fS0+Z2V0X2ZpZWxkKCAkZmllbGRuYW1lICk7CgkgICAg +ICAgICAgICAgICAgICAgICAgICBuZXh0IGlmICEkZmllbGQtPmdldF9wcm9wZXJ0eSggImV4cG9y +dF9hc194bWwiICk7CiAgICAgICAgCSAgICAgICAgICAgICAgICBuZXh0IGlmIGRlZmluZWQgJGZp +ZWxkLT57c3ViX25hbWV9OwoJCQkJICAgICAgICAgICAgbXkgJHZhbHVlID0gJGZpZWxkLT5nZXRf +dmFsdWUoICRlcGRhdGEgKTsKCQkJCSAgICAgICAgCWlmKCBkZWZpbmVkICRmaWVsZC0+e3ZpcnR1 +YWx9ICkKCQkJCSAgICAgICAgICAgIHsKCQkJCQkgICAgICAgICAgICAkdmFsdWUgPSBFUHJpbnRz +OjpVdGlsczo6dHJlZV90b191dGY4KCAkZXBkYXRhLT5yZW5kZXJfdmFsdWUoICRmaWVsZC0+Z2V0 +X25hbWUgKSApOwoJCQkJICAgICAgICAgICAgfQoJCSAgICAgICAgICAgICAgICAgICAgbmV4dCBp +ZiAhRVByaW50czo6VXRpbHM6OmlzX3NldCggJHZhbHVlICk7CiAgICAgICAgCSAgICAgICAgICAg +ICAgICAkc3ViZGF0YS0+eyRmaWVsZC0+Z2V0X25hbWV9ID0gJHZhbHVlOwogICAgICAgICAgICAg +ICAgICAgICAgICB9CgkJCSAgICAgICAgfQogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAg +ICAgJHN1YmRhdGEtPnt1cml9ID0gJGVwZGF0YS0+dXJpOwoKICAgICAgICAgICAgICAgIHJldHVy +biAkc2VsZi0+X2VwZGF0YV90b19qc29uKCAkc3ViZGF0YSwgJGRlcHRoICsgMSwgMCwgJW9wdHMg +KTsKICAgICAgICB9Cn0KCgpzdWIgZXNjYXBlX3ZhbHVlCnsKCW15KCAkcGx1Z2luLCAkdmFsdWUg +KSA9IEBfOwoKCXJldHVybiAnIiInIHVubGVzcyggZGVmaW5lZCBFUHJpbnRzOjpVdGlsczo6aXNf +c2V0KCAkdmFsdWUgKSApOwoKCSMgc3RyaXBzIGFueSBraW5kIG9mIGRvdWJsZS1xdW90ZXM6Cgkk +dmFsdWUgPX4gcy9ceDkzfFx4OTR8Ii8nL2c7CgkjIGFuZCBjb250cm9sLWNoYXJhY3RlcnMKCSR2 +YWx1ZSA9fiBzL1xufFxyfFx0Ly9nOwoKCSMgaWYgdmFsdWUgaXMgYSBwdXJlIG51bWJlciwgdGhl +biBhZGQgPSIkdmFsdWUiIHNvIHRoYXQgRXhjZWwgc3RvcHMgdGhlIGF1dG8tZm9ybWF0dGluZyAo +aXQnZCB0dXJuIDEyMzQ1NiBpbnRvIDEuMjNlKzYpCglpZiggJHZhbHVlID1+IC9eWzAtOVwtXSsk +LyApCgl7CgkJcmV0dXJuICI9XCIkdmFsdWVcIiI7Cgl9CgoJIyBvbmx5IGVzY2FwZXMgcm93IHdp +dGggc3BhY2VzIGFuZCBjb21tYXMKCWlmKCAkdmFsdWUgPX4gLyx8IC8gKQoJewoJCXJldHVybiAi +XCIkdmFsdWVcIiI7Cgl9CgoJcmV0dXJuICR2YWx1ZTsKfQoKCjE7Cg== + document plugins/EPrints/Plugin/Screen/Report.pm text/plain - 8bbbeeeb1dc8030c24e7814866e90e62 + 3f96896809763ee15750ac37e2c1b899 MD5 - 44075 + 45813 cGFja2FnZSBFUHJpbnRzOjpQbHVnaW46OlNjcmVlbjo6UmVwb3J0OwoKIyBBYnN0cmFjdCBjbGFz cyB0aGF0IGhhbmRsZXMgdGhlIFJlcG9ydCB0b29scwoKdXNlIEpTT04gcXcoZW5jb2RlX2pzb24p Owp1c2UgRVByaW50czo6UGx1Z2luOjpTY3JlZW47CkBJU0EgPSAoICdFUHJpbnRzOjpQbHVnaW46 @@ -810,742 +900,773 @@ cmVwb3J0X3BsdWdpbiA9ICRzZWxmLT57cHJvY2Vzc29yfS0+c2NyZWVuOwoKCSMgRG8gbm90IGNy ZWF0ZSBhIHNlYXJjaCBjb25maWcgaWYgdGhpcyBpcyBub3QgY29uZmlndXJlZCBpbiB0aGUgcmVw b3J0CiAgCXJldHVybiBpZiAhIGRlZmluZWQgJHJlcG9ydF9wbHVnaW4tPntzZWFyY2hkYXRhc2V0 aWR9OwoJJHNlbGYtPntwcm9jZXNzb3J9LT57cmVwb3J0X3BsdWdpbn0gPSAkcmVwb3J0X3BsdWdp -bjsKCiAgICAgICAgbXkgJHJlcG9ydF9kcyA9ICRzZXNzaW9uLT5kYXRhc2V0KCAkcmVwb3J0X3Bs -dWdpbi0+e3NlYXJjaGRhdGFzZXRpZH0gKTsKICAgICAgICBpZiggZGVmaW5lZCAkcmVwb3J0X2Rz -ICkKICAgICAgICB7CiAgICAgICAgICAgICAgICAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntkYXRhc2V0 -aWR9ID0gJHJlcG9ydF9kcy0+YmFzZV9pZDsKICAgICAgICAgICAgICAgIG15ICRzY29uZiA9ICRy -ZXBvcnRfZHMtPnNlYXJjaF9jb25maWcoICRyZXBvcnRfcGx1Z2luLT57c2NvbmZ9ICk7CgkKICAg -ICAgICAgICAgICAgIG15ICRmb3JtYXQgPSAicmVwb3J0LyIgLiAkcmVwb3J0X2RzLT5iYXNlX2lk -OwogICAgICAgICAgICAgICAgJHNlbGYtPntwcm9jZXNzb3J9LT57c2VhcmNofSA9ICRzZXNzaW9u -LT5wbHVnaW4oICJTZWFyY2giICktPnBsdWdpbnMoCiAgICAgICAgICAgICAgICAgICAgICAgIHsK -ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBrZWVwX2NhY2hlID0+IDEsCiAgICAgICAg -ICAgICAgICAgICAgICAgICAgICAgICAgc2Vzc2lvbiA9PiAkc2VsZi0+e3Nlc3Npb259LAogICAg -ICAgICAgICAgICAgICAgICAgICAgICAgICAgIGRhdGFzZXQgPT4gJHJlcG9ydF9kcywKICAgICAg -ICAgICAgICAgICAgICAgICAgICAgICAgICAleyRzY29uZn0KICAgICAgICAgICAgICAgICAgICAg -ICAgfSwKICAgICAgICAgICAgICAgICAgICAgICAgdHlwZSA9PiAiU2VhcmNoIiwKICAgICAgICAg -ICAgICAgICAgICAgICAgY2FuX3NlYXJjaCA9PiAkZm9ybWF0LAogICAgICAgICAgICAgICAgKTsK -CX0KfQoKc3ViIGFsbG93X25ld3NlYXJjaCB7IHJldHVybiAxOyB9CgpzdWIgYWxsb3dfdXBkYXRl -IHsgcmV0dXJuIDE7IH0KCnN1YiBhY3Rpb25fbmV3c2VhcmNoCnsKICAgICAgICBteSggJHNlbGYg -KSA9IEBfOwoKICAgICAgICBteSAkc2Vzc2lvbiA9ICRzZWxmLT57c2Vzc2lvbn07CgogICAgICAg -ICMkc2VsZi0+e3Byb2Nlc3Nvcn0tPntyZXBvcnR9ID0gJHNlc3Npb24tPnBhcmFtKCAncmVwb3J0 -JyApOwogICAgICAgICMkc2VsZi0+e3Byb2Nlc3Nvcn0tPntzY3JlZW5pZH0gPSAkc2VsZi0+e3By -b2Nlc3Nvcn0tPntyZXBvcnR9OwogICAgICAgICMkc2VsZi0+e3Byb2Nlc3Nvcn0tPnthY3Rpb259 -ID0gIm5ld3NlYXJjaCI7CiAgICAgICAgIyRzZWxmLT5fY3JlYXRlX3NlYXJjaDsKfQoKc3ViIGFj -dGlvbl91cGRhdGUKewogICAgICAgIG15KCAkc2VsZiApID0gQF87CgogICAgICAgIG15ICRzZXNz -aW9uID0gJHNlbGYtPntzZXNzaW9ufTsKCiAgICAgICAgIyRzZWxmLT57cHJvY2Vzc29yfS0+e3Jl -cG9ydH0gPSAkc2Vzc2lvbi0+cGFyYW0oICdyZXBvcnQnICk7CiAgICAgICAgIyRzZWxmLT57cHJv -Y2Vzc29yfS0+e3NjcmVlbmlkfSA9ICRzZWxmLT57cHJvY2Vzc29yfS0+e3JlcG9ydH07CiAgICAg -ICAgIyRzZWxmLT57cHJvY2Vzc29yfS0+e2FjdGlvbn0gPSAibmV3c2VhcmNoIjsKICAgICAgICAj -JHNlbGYtPl9jcmVhdGVfc2VhcmNoOwp9CgpzdWIgYWN0aW9uX3NlYXJjaAp7CglteSggJHNlbGYg -KSA9IEBfOwoKCSRzZWxmLT57cHJvY2Vzc29yfS0+e2FjdGlvbn0gPSAic2VhcmNoIjsKCgkjcmVh -ZCBwYXJhbWV0ZXJzCglteSAkc2Vzc2lvbiA9ICRzZWxmLT57c2Vzc2lvbn07CgoJJHNlbGYtPntw -cm9jZXNzb3J9LT57cmVwb3J0fSA9ICRzZXNzaW9uLT5wYXJhbSggJ3JlcG9ydCcgKTsKCgkkc2Vs -Zi0+e3Byb2Nlc3Nvcn0tPntzY3JlZW5pZH0gPSAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntyZXBvcnR9 -OwoJJHNlbGYtPl9jcmVhdGVfc2VhcmNoOwoKCW15ICRsb2FkZWQgPSAwOwogICAgICAgIG15ICRp -ZCA9ICRzZXNzaW9uLT5wYXJhbSggImNhY2hlIiApOwogICAgICAgIGlmKCBkZWZpbmVkICRpZCAp -CiAgICAgICAgewoJCSRsb2FkZWQgPSAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntzZWFyY2h9LT5mcm9t -X2NhY2hlKCAkaWQgKTsKICAgICAgICB9CgogICAgICAgIGlmKCAhJGxvYWRlZCApCiAgICAgICAg -ewogICAgICAgICAgICAgICAgbXkgJGV4cCA9ICRzZXNzaW9uLT5wYXJhbSggImV4cCIgKTsKICAg -ICAgICAgICAgICAgIGlmKCBkZWZpbmVkICRleHAgKQogICAgICAgICAgICAgICAgewoJCQkkc2Vs -Zi0+e3Byb2Nlc3Nvcn0tPntzZWFyY2h9LT5mcm9tX3N0cmluZyggJGV4cCApOwogICAgICAgICAg -ICAgICAgICAgICAgICAjIGNhY2hlIGV4cGlyZWQuLi4KICAgICAgICAgICAgICAgICAgICAgICAg -JGxvYWRlZCA9IDE7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgfQoKICAgICAgICBteSBAcHJv -YmxlbXM7CiAgICAgICAgaWYoICEkbG9hZGVkICkKICAgICAgICB7CgkJZm9yKCAkc2VsZi0+e3By -b2Nlc3Nvcn0tPntzZWFyY2h9LT5mcm9tX2Zvcm0gKQogICAgICAgICAgICAgICAgICAgICAgICB7 -CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJHNlbGYtPntwcm9jZXNzb3J9LT5hZGRf -bWVzc2FnZSggIndhcm5pbmciLCAkXyApOwogICAgICAgICAgICAgICAgICAgICAgICB9CiAgICAg -ICAgfQogICAgICAgICAgCgoJI2Rpc3BsYXkgdGhlIHJlc3VsdHMKCSRzZWxmLT5yZW5kZXI7Cn0K -CnN1YiBwcm9wZXJ0aWVzX2Zyb20KewoJbXkoICRzZWxmICkgPSBAXzsKCglteSAkcmVwbyA9ICRz -ZWxmLT5yZXBvc2l0b3J5OwoJJHNlbGYtPlNVUEVSOjpwcm9wZXJ0aWVzX2Zyb207CgoJaWYoIGRl -ZmluZWQgKCBteSAkZHNpZCA9ICRzZWxmLT5wYXJhbSggImRhdGFzZXRpZCIgKSApICkKCXsKCQkk -c2VsZi0+e3Byb2Nlc3Nvcn0tPntkYXRhc2V0fSA9ICRzZWxmLT5yZXBvc2l0b3J5LT5kYXRhc2V0 -KCAkZHNpZCApOwoJfQoKCSMgc2YyIC0gVE9ETyAtIGJhcmsgaWYgZGF0YXNldCBpcyBub3Qgc2V0 -PyBwZXJoYXBzIHRoZXJlIGFyZSBvdGhlciB3YXlzIHRvIGdldCB0aGUgb2JqZWN0cyBmcm9tLi4u -CglteSAkcmVwb3J0ID0gJHNlbGYtPmdldF9yZXBvcnQoKTsKCgkjZ2V0IGEgc2VhcmNoIG9iamVj -dCBpZiB3ZSBoYXZlIG9uZSBmcm9tIGEgcHJldmlvdXMgc2VhcmNoIGFjdGlvbiwgc28gdGhhdCB3 -ZSBtaWdodCBsYXRlciB1c2UgaXQgdG8gZG8gYW4gZXhwb3J0IG9yIHNlYXJjaCBhY3Rpb24KCSRz -ZWxmLT5fY3JlYXRlX3NlYXJjaDsJCglpZiggZGVmaW5lZCAkc2VsZi0+cmVwb3NpdG9yeS0+cGFy -YW0oICJzZWFyY2giICkgKQoJewoJCSRzZWxmLT57cHJvY2Vzc29yfS0+e3NlYXJjaH0tPmZyb21f -c3RyaW5nKCAkc2VsZi0+cmVwb3NpdG9yeS0+cGFyYW0oICJzZWFyY2giICkgKSBpZiBkZWZpbmVk -ICRzZWxmLT57cHJvY2Vzc29yfS0+e3NlYXJjaH07CgkJJHNlbGYtPntwcm9jZXNzb3J9LT57ZXhw -b3J0X3NlYXJjaH0gPSAxOwoJfQoJCglteSAkZm9ybWF0ID0gJHNlbGYtPnJlcG9zaXRvcnktPnBh -cmFtKCAiZXhwb3J0IiApOwoJaWYoICRmb3JtYXQgJiYgJHJlcG9ydCApCgl7CgkJbXkgJHBsdWdp -biA9ICRzZWxmLT5yZXBvc2l0b3J5LT5wbHVnaW4oICJFeHBvcnQ6OiRmb3JtYXQiLCByZXBvcnQg -PT4gJHJlcG9ydCApOwoJCWlmKCBkZWZpbmVkICRwbHVnaW4gJiYgKCAkcGx1Z2luLT5jYW5fYWNj -ZXB0KCAicmVwb3J0LyRyZXBvcnQiICkgfHwgKCRwbHVnaW4tPmNhbl9hY2NlcHQoICJyZXBvcnQv -Z2VuZXJpYyIgKSApICkgKQoJCXsKCQkJJHNlbGYtPntwcm9jZXNzb3J9LT57cGx1Z2lufSA9ICRw -bHVnaW47CgkJfQoJfQoKCSNsaXN0IG9mIGV4cG9ydCBmaWVsZHMgcmV0cmlldmVkIGZyb20gbm9u -LWFic3RyYWN0IGluc3RhbmNlcyBvZiByZXBvcnRzCglteSBAZXhwb3J0ZmllbGRzOwoJaWYoIGRl -ZmluZWQgJHJlcG8tPmNvbmZpZyggJHNlbGYtPntleHBvcnRfY29uZn0sICJleHBvcnRmaWVsZHMi -ICkgKQoJewoJCW15IEBrZXlzOwoJCWlmKCBkZWZpbmVkICRyZXBvLT5jb25maWcoICRzZWxmLT57 -ZXhwb3J0X2NvbmZ9LCAiZXhwb3J0ZmllbGRfb3JkZXIiICkgKQoJCXsKCQkJQGtleXMgPSBAeyRy -ZXBvLT5jb25maWcoICRzZWxmLT57ZXhwb3J0X2NvbmZ9LCAiZXhwb3J0ZmllbGRfb3JkZXIiICl9 -OwoJCX0KCQllbHNlCgkJewoJCQlAa2V5cyA9IGtleXMgJXskcmVwby0+Y29uZmlnKCAkc2VsZi0+ -e2V4cG9ydF9jb25mfSwgImV4cG9ydGZpZWxkcyIgKX07IAoJCX0KCQlmb3JlYWNoIG15ICRrZXkg -KCBAa2V5cyApCgkJewoJCQlmb3JlYWNoIG15ICRmaWVsZG5hbWUgKCBAeyRyZXBvLT5jb25maWco -ICRzZWxmLT57ZXhwb3J0X2NvbmZ9LCAiZXhwb3J0ZmllbGRzIiApLT57JGtleX19ICkKCQkJewoJ -CQkJcHVzaCBAZXhwb3J0ZmllbGRzLCAkZmllbGRuYW1lIGlmIGRlZmluZWQgJHNlbGYtPnJlcG9z -aXRvcnktPnBhcmFtKCAkZmllbGRuYW1lICk7IAoJCQl9CgkJfQoJfQoKCW15ICRzb3J0ID0gJHNl -bGYtPnJlcG9zaXRvcnktPnBhcmFtKCAic29ydCIgKTsKCWlmKCBkZWZpbmVkICRzb3J0ICkKCXsK -CQkkc2VsZi0+e3Byb2Nlc3Nvcn0tPntzb3J0fSA9ICRzb3J0OwoJfQoKCW15ICRncm91cCA9ICRz -ZWxmLT5yZXBvc2l0b3J5LT5wYXJhbSggImdyb3VwIiApOwoJJHNlbGYtPntwcm9jZXNzb3J9LT57 -Z3JvdXBfZXhwfSA9ICRncm91cDsgI3N0b3JlIHRoZSBncm91cCBleHByZXNzaW9uIGZvciBsYXRl -ciB1c2UKCQoJI2RlY29kZSB0aGUgZ3JvdXAgZXhwcmVzc2lvbgoJbXkgJWdyb3VwX29wdHM7Cglp -ZiggZGVmaW5lZCAkZ3JvdXAgKQoJewoJCSNnZXQgZmllbGQgYW5kIGFzc29jaWF0ZWQgY29uZmln -dXJhdGlvbiBhYm91dCB0aGUgZ3JvdXAsIGUuZy4gcmVzLCB0cnVuY2F0ZSwgcmV2ZXJzZV9vcmRl -ciBldGMuCgkJbXkgQGdyb3VwID0gc3BsaXQoLzsvLCAkZ3JvdXAgKTsKCQlteSAkZmlyc3QgPSAx -OwoJCWZvcmVhY2ggbXkgJGcgKEBncm91cCkKCQl7CgkJCWlmKCAkZmlyc3QgKQoJCQl7CgkJCQkk -Z3JvdXAgPSAkZzsKCQkJfQoJCQllbHNlCgkJCXsKCQkJCW15IEBvcHRzID0gc3BsaXQoLz0vLCAk -ZyApOwoJCQkJJGdyb3VwX29wdHN7JG9wdHNbMF19ID0gJG9wdHNbMV07CQkKCQkJfQoJCQkkZmly -c3QgPSAwOwoJCX0KCQkkc2VsZi0+e3Byb2Nlc3Nvcn0tPntncm91cH0gPSAkZ3JvdXA7CgkJJHNl -bGYtPntwcm9jZXNzb3J9LT57Z3JvdXBfb3B0c30gPSBcJWdyb3VwX29wdHM7Cgl9CgoJJHNlbGYt -Pntwcm9jZXNzb3J9LT57ZXhwb3J0ZmllbGRzfSA9IFxAZXhwb3J0ZmllbGRzOwp9CgkJCiMgXEAo -e21ldGFfZmllbGRzPT5bICJmaWVsZDEiLCAiZmllbGQyIiAiZG9jdW1lbnQuZmllbGQzIiBdLCBt -ZXJnZT0+IkFOWSIsIG1hdGNoPT4iRVgiLCB2YWx1ZT0+ImJlZXMifSwge21ldGFfZmllbGRzPT5b -ICJmaWVsZDQiIF0sIHZhbHVlPT4iaG9uZXkifSk7CiMgZS5nLgojIHJldHVybiBbIHsgbWV0YV9m -aWVsZHMgPT4gWyAndHlwZScgXSwgdmFsdWUgPT4gJ2FydGljbGUnIH0gXQpzdWIgZmlsdGVycwp7 -CglyZXR1cm4gW107Cn0KCiMgaG93IHRvIHNlbGVjdCBpdGVtcyBpLmUuIHRoZSBzbGljZSBvZiBk -YXRhIHdlIHdhbnQgdG8gdmFsaWRhdGUvZXhwb3J0PwojIApzdWIgaXRlbXMKewoJbXkoICRzZWxm -ICkgPSBAXzsKCWlmKCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPnthY3Rpb259IGVxICJzZWFyY2giIHx8 -ICRzZWxmLT57cHJvY2Vzc29yfS0+e2V4cG9ydF9zZWFyY2h9ICkKICAgICAgIAl7CgkJbXkgJHJl -cG9ydCA9ICRzZWxmLT57cHJvY2Vzc29yfS0+e3JlcG9ydF9wbHVnaW59OwkKCQkkcmVwb3J0LT5h -cHBseV9maWx0ZXJzIGlmICRyZXBvcnQtPmNhbiggJ2FwcGx5X2ZpbHRlcnMnICk7CgoJCW15ICRp -dGVtcyA9ICRzZWxmLT57cHJvY2Vzc29yfS0+e3NlYXJjaH0tPnBlcmZvcm1fc2VhcmNoOwoKCQlp -ZiggZGVmaW5lZCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntzb3J0fSApCgkJewkKCQkJJGl0ZW1zID0g -JGl0ZW1zLT5yZW9yZGVyKCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntzb3J0fSApOwoJCX0KCQlyZXR1 -cm4gJGl0ZW1zOwoJfQoJZWxzaWYoIGRlZmluZWQgJHNlbGYtPntwcm9jZXNzb3J9LT57ZGF0YXNl -dH0gKSAKCXsKCQlteSAlc2VhcmNoX29wdHMgPSAoIGZpbHRlcnMgPT4gJHNlbGYtPmZpbHRlcnMs -IHNhdGlzZnlfYWxsID0+IDEgKTsKCQlpZiggZGVmaW5lZCAkc2VsZi0+cGFyYW0oICdjdXN0b21f -b3JkZXInICkgKQoJCXsKCQkJJHNlYXJjaF9vcHRze2N1c3RvbV9vcmRlcn0gPSAkc2VsZi0+cGFy -YW0oICdjdXN0b21fb3JkZXInICk7CgkJfQoKCQlpZiggZGVmaW5lZCAkc2VsZi0+e3Byb2Nlc3Nv -cn0tPntzb3J0fSApICNhbiBvcmRlcmluZyBzcGVjaWZpZWQgYnkgdGhlIHVzZXIgc2hvdWxkIHRy -dW1wIHRoZSByZXBvcnRzIGN1c3RvbSBvcmRlcgoJCXsKCQkJJHNlYXJjaF9vcHRze2N1c3RvbV9v -cmRlcn0gPSAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntzb3J0fTsKCQl9CQoJCXJldHVybiAkc2VsZi0+ -e3Byb2Nlc3Nvcn0tPntkYXRhc2V0fS0+c2VhcmNoKCAlc2VhcmNoX29wdHMgKTsKCX0KCSMgd2Ug -Y2FuJ3QgcmV0dXJuIGFuIEVQcmludHM6Okxpc3QgaWYge2RhdGFzZXR9IGlzIG5vdCBkZWZpbmVk -CglyZXR1cm4gdW5kZWY7Cn0KCiMgZnJvbSBSZXBvcnRzL1JPUy9Kb3VybmFscy5wbQojIFRPRE8g -Tm90ZSBxdWl0ZSBhIGxvdCBvZiByZXBsaWNhdGlvbiBiZXR3ZWVuIHRoaXMgYW5kIEV4cG9ydDo6 -UmVwb3J0OjpDU1Y6Om91dHB1dF9kYXRhb2JqCnN1YiB2YWxpZGF0ZV9kYXRhb2JqCnsKCW15KCAk -cGx1Z2luLCAkZGF0YW9iaiApID0gQF87CgoJbXkgJHJlcG8gPSAkcGx1Z2luLT5yZXBvc2l0b3J5 -OwoKCW15ICRyZXBvcnRfZmllbGRzID0gJHBsdWdpbi0+cmVwb3J0X2ZpZWxkcyggJGRhdGFvYmog -KTsKCW15ICR2YWxfZmllbGRzID0gJHBsdWdpbi0+dmFsaWRhdGVfZmllbGRzKCAkZGF0YW9iaiAp -OwoKCSMgcmVsYXRlZCBvYmplY3RzIGFuZCB0aGVpciBkYXRhc2V0cwoJbXkgJG9iamVjdHMgPSAk -cGx1Z2luLT5nZXRfcmVsYXRlZF9vYmplY3RzKCAkZGF0YW9iaiApOwoJbXkgJHZhbGlkX2RzID0g -e307Cglmb3JlYWNoIG15ICRkc2lkICgga2V5cyAlJG9iamVjdHMgKQoJewoJCSR2YWxpZF9kcy0+ -eyRkc2lkfSA9ICRyZXBvLT5kYXRhc2V0KCAkZHNpZCApOwoJfQoKCW15IEBwcm9ibGVtczsKCglm -b3JlYWNoIG15ICRmaWVsZCAoIEB7ICRwbHVnaW4tPnJlcG9ydF9maWVsZHNfb3JkZXIoICRkYXRh -b2JqICkgfHwgW10gfSApCgl7CgkJIyB2YWxpZGF0aW9uIGFjdGlvbgoJCW15ICR2X2ZpZWxkID0g -JHZhbF9maWVsZHMtPnskZmllbGR9OwoJCW5leHQgdW5sZXNzIGRlZmluZWQgJHZfZmllbGQ7ICMg -bm8gdmFsaWRhdGlvbiByZXF1aXJlZAoKCQkjIHNpbXBsZSBjYXNlIC0gY29kZSBoYW5kbGVzIHZh -bGlkYXRpb24KCQlpZiggcmVmKCAkdl9maWVsZCApIGVxICdDT0RFJyApCgkJewoJCQkjIGEgc3Vi -e30gd2UgbmVlZCB0byBydW4KCQkJZXZhbCB7CgkJCQkmJHZfZmllbGQoICRwbHVnaW4sICRvYmpl -Y3RzLCBcQHByb2JsZW1zICk7CgkJCX07CgkJCWlmKCAkQCApCgkJCXsKCQkJCSRyZXBvLT5sb2co -ICJWYWxpZGF0aW9uIFJ1bnRpbWUgZXJyb3I6ICRAIiApOwoJCQl9CgkJCW5leHQ7CgkJfQoJCWVs -c2lmKCBsYyAkdl9maWVsZCBuZSAicmVxdWlyZWQiICkKCQl7CgkJCSRyZXBvLT5sb2coICJWYWxp -ZGF0aW9uIFJ1bnRpbWUgZXJyb3I6ICR2X2ZpZWxkIG11c3QgYmUgY29kZSByZWYgb3IgJ3JlcXVp -cmVkJyIgKTsKCQkJbmV4dDsKCQl9CgoJCSMgY2hlY2sgcmVxdWlyZWQgdmFsdWVzCgoJCW15ICR2 -YWx1ZTsgIyB0aGUgdmFsdWUgdG8gdmFsaWRhdGUKCQlteSAkZXBfZmllbGQgPSAkcmVwb3J0X2Zp -ZWxkcy0+eyRmaWVsZH07CgkJaWYoIHJlZiggJGVwX2ZpZWxkICkgZXEgJ0NPREUnICkKCQl7CgkJ -CSMgYSBzdWJ7fSB3ZSBuZWVkIHRvIHJ1bgoJCQlldmFsIHsKCQkJCSR2YWx1ZSA9ICYkZXBfZmll -bGQoICRwbHVnaW4sICRvYmplY3RzICk7CgkJCX07CgkJCWlmKCAkQCApCgkJCXsKCQkJCSRyZXBv -LT5sb2coICJWYWxpZGF0aW9uIFJ1bnRpbWUgZXJyb3I6ICRAIiApOwoJCQl9CgkJfQoJCWVsc2lm -KCAkZXBfZmllbGQgPX4gL14oW2Etel9dKylcLihbMC05YS16X10rKSQvICkKCQl7CgkJCSMgYSBz -dHJhaWdodCBtYXBwaW5nIHdpdGggYW4gRVByaW50cyBmaWVsZAoJCQlteSggJGRzX2lkLCAkZXBf -ZmllbGRuYW1lICkgPSAoICQxLCAkMiApOwoJCQlteSAkZHMgPSAkdmFsaWRfZHMtPnskZHNfaWR9 -OwoKCQkJaWYoIGRlZmluZWQgJGRzICYmICRkcy0+aGFzX2ZpZWxkKCAkZXBfZmllbGRuYW1lICkg -KQoJCQl7CgkJCQkkdmFsdWUgPSAkb2JqZWN0cy0+eyRkc19pZH0tPnZhbHVlKCAkZXBfZmllbGRu -YW1lICk7CgkJCX0KCQkJZWxzZQoJCQl7CgkJCQkjIGRhdGFzZXQgb3IgZmllbGQgZG9lc24ndCBl -eGlzdAoJCQkJJHJlcG8tPmxvZyggIlZhbGlkYXRpb24gUnVudGltZSBlcnJvcjogZGF0YXNldCAk -ZHNfaWQgb3IgZmllbGQgJGVwX2ZpZWxkbmFtZSBkb2Vzbid0IGV4aXN0IiApOwoJCQl9CgkJfQoK -CQkjIGlzIGZpZWxkIHNldD8KCQlpZiggIUVQcmludHM6OlV0aWxzOjppc19zZXQoICR2YWx1ZSAp -ICkKCQl7CgkJCXB1c2ggQHByb2JsZW1zLCAiTWlzc2luZyByZXF1aXJlZCBmaWVsZCAkZmllbGQi -OwoJCX0KCX0KCglyZXR1cm4gQHByb2JsZW1zOwp9CgojIFRPRE8gTm90ZSBjb3B5IG9mIEV4cG9y -dDo6UmVwb3J0OjpnZXRfcmVsYXRlZF9vYmplY3RzCnN1YiBnZXRfcmVsYXRlZF9vYmplY3RzCnsK -CW15KCAkcGx1Z2luLCAkZGF0YW9iaiApID0gQF87CgoJbXkgJGNtZCA9IFsgJ3JlcG9ydHMnLCAk -cGx1Z2luLT5nZXRfcmVwb3J0LCAnZ2V0X3JlbGF0ZWRfb2JqZWN0cycgXTsKICAgICAgICBpZigg -JHBsdWdpbi0+cmVwb3NpdG9yeS0+Y2FuX2NhbGwoIEAkY21kICkgKQogICAgICAgIHsKCQlyZXR1 -cm4gJHBsdWdpbi0+cmVwb3NpdG9yeS0+Y2FsbCggJGNtZCwgJHBsdWdpbi0+cmVwb3NpdG9yeSwg -JGRhdGFvYmogKSB8fCB7fTsKICAgICAgICB9CgoJIyBqdXN0IHBhc3MgdGhlIGRhdGFvYmogaXRz -ZWxmCglyZXR1cm4gewoJCSRkYXRhb2JqLT5kYXRhc2V0LT5jb25maWQgPT4gJGRhdGFvYmosCgl9 -Owp9CgojIFRPRE8gTm90ZSBjb3B5IG9mIEV4cG9ydDo6UmVwb3J0OjpyZXBvcnRfZmllbGRzX29y -ZGVyCnN1YiByZXBvcnRfZmllbGRzX29yZGVyCnsKCW15KCAkcGx1Z2luICkgPSBAXzsKCglyZXR1 -cm4gJHBsdWdpbi0+e3JlcG9ydF9maWVsZHNfb3JkZXJ9IGlmKCBkZWZpbmVkICRwbHVnaW4tPnty -ZXBvcnRfZmllbGRzX29yZGVyfSApOwoKCW15ICRyZXBvcnQgPSAkcGx1Z2luLT5nZXRfcmVwb3J0 -KCk7CglyZXR1cm4gW10gdW5sZXNzKCBkZWZpbmVkICRyZXBvcnQgKTsKCgkkcGx1Z2luLT57cmVw -b3J0X2ZpZWxkc19vcmRlcn0gPSAkcGx1Z2luLT5yZXBvc2l0b3J5LT5jb25maWcoICdyZXBvcnRz -JywgJHJlcG9ydCwgJ2ZpZWxkcycgKTsKCglyZXR1cm4gJHBsdWdpbi0+e3JlcG9ydF9maWVsZHNf -b3JkZXJ9Owp9CgojIFRPRE8gTm90ZSBjb3B5IG9mIEV4cG9ydDo6UmVwb3J0OjpyZXBvcnRfZmll -bGRzCnN1YiByZXBvcnRfZmllbGRzCnsKCW15KCAkcGx1Z2luICkgPSBAXzsKCglyZXR1cm4gJHBs -dWdpbi0+e3JlcG9ydF9maWVsZHN9IGlmKCBkZWZpbmVkICRwbHVnaW4tPntyZXBvcnRfZmllbGRz -fSApOwoKCW15ICRyZXBvcnQgPSAkcGx1Z2luLT5nZXRfcmVwb3J0KCk7CglyZXR1cm4gW10gdW5s -ZXNzKCBkZWZpbmVkICRyZXBvcnQgKTsKCgkkcGx1Z2luLT57cmVwb3J0X2ZpZWxkc30gPSAkcGx1 -Z2luLT5yZXBvc2l0b3J5LT5jb25maWcoICdyZXBvcnRzJywgJHJlcG9ydCwgJ21hcHBpbmdzJyAp -OwoKCXJldHVybiAkcGx1Z2luLT57cmVwb3J0X2ZpZWxkc307Cn0KCnN1YiB2YWxpZGF0ZV9maWVs -ZHMKewoJbXkoICRwbHVnaW4gKSA9IEBfOwoKCXJldHVybiAkcGx1Z2luLT57dmFsaWRhdGVfZmll -bGRzfSBpZiggZGVmaW5lZCAkcGx1Z2luLT57dmFsaWRhdGVfZmllbGRzfSApOwoKCW15ICRyZXBv -cnQgPSAkcGx1Z2luLT5nZXRfcmVwb3J0KCk7CglyZXR1cm4gW10gdW5sZXNzKCBkZWZpbmVkICRy -ZXBvcnQgKTsKCgkkcGx1Z2luLT57dmFsaWRhdGVfZmllbGRzfSA9ICRwbHVnaW4tPnJlcG9zaXRv -cnktPmNvbmZpZyggJ3JlcG9ydHMnLCAkcmVwb3J0LCAndmFsaWRhdGUnICk7CgoJcmV0dXJuICRw -bHVnaW4tPnt2YWxpZGF0ZV9maWVsZHN9Owp9CgojIyByZW5kZXJpbmcKCiMgVGhlICJzcGxhc2gg -cGFnZSIKc3ViIHJlbmRlcl9zcGxhc2hfcGFnZQp7CglteSggJHNlbGYgKSA9IEBfOwoKCW15ICRy -ZXBvID0gJHNlbGYtPnJlcG9zaXRvcnk7CglteSBAcGx1Z2lucyA9ICRzZWxmLT5yZXBvcnRfcGx1 -Z2luczsKCglpZiggIXNjYWxhciggQHBsdWdpbnMgKSApCgl7CgkJcmV0dXJuICRzZWxmLT5odG1s -X3BocmFzZSggIm5vX3JlcG9ydHMiICk7Cgl9CgoJbXkgQGxhYmVsczsKCW15IEBwYW5lbHM7CgoJ -I3ByZXNldCByZXBvcnRzCglwdXNoIEBsYWJlbHMsICRyZXBvLT5odG1sX3BocmFzZSggInJlcG9y -dHNfcHJlc2V0IiApOwoJbXkgJHByZXNldCA9ICRyZXBvLT5tYWtlX2VsZW1lbnQoICJkaXYiICk7 -CglteSAkcHJlc2V0c19hZGRlZCA9IDA7CgoJIyB0b3AgY2F0ZWdvcnk6IGJ5IGNsYXNzbmFtZSA+ -IFJlcG9ydDo6Uk9TOjpTb21lUmVwb3J0MSwgUmVwb3J0OjpST1M6OlNvbWVSZXBvcnQyCgoJbXkg -JHVsID0gJHNlbGYtPnJlcG9zaXRvcnktPm1ha2VfZWxlbWVudCggJ3VsJywgY2xhc3MgPT4gJ2Vw -X3JlcG9ydF9jYXRlZ29yeScgKTsKCgkjIGNhdCB+IGNhdGVnb3J5IC0gIW1lZW93CglteSAkY2F0 -ID0gIiI7CglteSAkY2F0X2xpID0gdW5kZWY7IAoJbXkgJGNhdF91bCA9IHVuZGVmOwoJCgkjcHJl -cGFyZSBoYXNoIG9mIHJlcG9ydGluZyBwbHVnaW5zCglteSAlcmVwb3J0X2hhc2g7Cglmb3JlYWNo -IG15ICRyZXBvcnRfcGx1Z2luICggc29ydCB7ICRhLT5nZXRfc3VidHlwZSBjbXAgJGItPmdldF9z -dWJ0eXBlIH0gQHBsdWdpbnMgKQoJewoJCW15ICRwbHVnaW5fY2F0ID0gJHJlcG9ydF9wbHVnaW4t -PmdldF9zdWJ0eXBlOwoJCSRwbHVnaW5fY2F0ID1+IHMvXlJlcG9ydDo6KFteOl0rKTo/Oj8oLiop -JC8kMS9nOwkKCgkJaWYoICRjYXQgbmUgJHBsdWdpbl9jYXQgKSAjd2UgaGF2ZSBhIHRvcC1jYXRl -Z29yeQoJCXsKCQkJJGNhdCA9ICRwbHVnaW5fY2F0OwoJCQkkcmVwb3J0X2hhc2h7JGNhdH0gPSBb -XTsKCQl9CgoJCWlmKCBFUHJpbnRzOjpVdGlsczo6aXNfc2V0KCAkMiApICkKCQl7CgkJCXB1c2gg -QHskcmVwb3J0X2hhc2h7JGNhdH19LCAkcmVwb3J0X3BsdWdpbjsKCQl9Cgl9CgkKCWZvciBteSAk -dG9wX2NhdCggc29ydCBrZXlzICVyZXBvcnRfaGFzaCApCgl7CgkJbXkgQHJlcG9ydF9wbHVnaW5z -ID0gQHskcmVwb3J0X2hhc2h7JHRvcF9jYXR9fTsKCQlpZiggc2NhbGFyKCBAcmVwb3J0X3BsdWdp -bnMgKSA+IDAgKQoJCXsKCQkJI3JlbmRlciB0b3AtY2F0ZWdvcnkKCQkJJGNhdF9saSA9ICR1bC0+ -YXBwZW5kQ2hpbGQoICRzZWxmLT5yZXBvc2l0b3J5LT5tYWtlX2VsZW1lbnQoICdsaScgKSApOwoJ -CQkkY2F0X2xpLT5hcHBlbmRDaGlsZCggJHNlbGYtPnJlcG9zaXRvcnktPmh0bWxfcGhyYXNlKCAi -UGx1Z2luL1NjcmVlbi9SZXBvcnQvJHRvcF9jYXQ6dGl0bGUiICkgKTsKCgkJCSRjYXRfdWwgPSAk -Y2F0X2xpLT5hcHBlbmRDaGlsZCggJHNlbGYtPnJlcG9zaXRvcnktPm1ha2VfZWxlbWVudCggJ3Vs -JywgY2xhc3MgPT4gJ2VwX3JlcG9ydF9pdGVtcycgKSApOwoKCQkJZm9yZWFjaCBteSAkciAoIEBy -ZXBvcnRfcGx1Z2lucyApCgkJCXsKCQkJCW15ICRzdWJfbGkgPSAkY2F0X3VsLT5hcHBlbmRDaGls -ZCggJHNlbGYtPnJlcG9zaXRvcnktPm1ha2VfZWxlbWVudCggJ2xpJyApICk7CgkJCQkkc3ViX2xp -LT5hcHBlbmRDaGlsZCggJHItPnJlbmRlcl9hY3Rpb25fbGluayApOwoJCQkJJHByZXNldHNfYWRk -ZWQrKzsKCQkJfQoJCX0KCX0KCgkkcHJlc2V0LT5hcHBlbmRDaGlsZCggJHVsICk7CglwdXNoIEBw -YW5lbHMsICRwcmVzZXQ7CgoJI2N1c3RvbSByZXBvcnRzCglwdXNoIEBsYWJlbHMsICRyZXBvLT5o -dG1sX3BocmFzZSggInJlcG9ydHNfY3VzdG9tIiApOwoKCW15ICRjdXN0b20gPSAkcmVwby0+bWFr -ZV9lbGVtZW50KCAiZGl2IiwgaWQ9PiJjdXN0b21fcmVwb3J0IiApOwoJbXkgJGZvcm0gPSAkcmVw -by0+cmVuZGVyX2Zvcm0oICJnZXQiICk7CgoJJGZvcm0tPmFwcGVuZENoaWxkKCAkc2VsZi0+cmVu -ZGVyX2NvbnRyb2xzKCAxICkgKTsKCgkjYWRkIGVhY2ggcmVwb3J0IHRvIHRoZSBzZWxlY3QgY29t -cG9uZW50IGFuZCBnZW5lcmF0ZSBzZWFyY2ggZm9ybSBpZiByZXF1aXJlZAoJbXkgJHJlcG9ydF9z -ZWxlY3QgPSAkcmVwby0+bWFrZV9lbGVtZW50KCAic2VsZWN0IiwgbmFtZT0+InJlcG9ydCIsIGlk -PT4ic2VsZWN0X3JlcG9ydCIgKTsKCW15ICVzZWFyY2hfZm9ybXM7CglteSAkY3VzdG9tX3JlcG9y -dHMgPSAwOwoJI2ZvcmVhY2ggbXkgJHJlcG9ydF9wbHVnaW4gKCBAcGx1Z2lucyApCglmb3JlYWNo -IG15ICRyZXBvcnRfcGx1Z2luICggc29ydCB7ICRhLT5nZXRfc3VidHlwZSBjbXAgJGItPmdldF9z -dWJ0eXBlIH0gQHBsdWdpbnMgKQoJewoJCWlmKCAkcmVwb3J0X3BsdWdpbi0+cGFyYW0oICJjdXN0 -b20iICkgKQoJCXsJCgkJCSRjdXN0b21fcmVwb3J0cysrOwoJCQlteSAkZm9ybWlkID0gJHJlcG9y -dF9wbHVnaW4tPntzY29uZn07CgoJCQkjYWRkIHRvIHNlbGVjdCBjb21wb25lbnQKCQkJbXkgJGlk -ID0gJHJlcG9ydF9wbHVnaW4tPntyZXBvcnR9OwoJCQlteSAkb3B0aW9uID0gJHJlcG8tPm1ha2Vf -ZWxlbWVudCggIm9wdGlvbiIsIHZhbHVlID0+ICRyZXBvcnRfcGx1Z2luLT5nZXRfc3VidHlwZSwg -Zm9ybSA9PiAkZm9ybWlkICk7CgoJCQkjc2V0IGRlZmF1bHQgb3B0aW9uIGZvciBzZWxlY3QgY29t -cG9uZW50IGlmIHJlcXVpcmVkIChpLmUuIHdlIGhhdmUgY29tZSBmcm9tIGEgcmVmaW5lIHNlYXJj -aCBvciBuZXcgc2VhcmNoIGxpbmspCgkJCW15ICRyZWZpbmVfc2NvbmYgPSAkc2VsZi0+e3Nlc3Np -b259LT5wYXJhbSggInNjb25mIiApOwoJCQlpZiggKCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPnthY3Rp -b259IGVxICJ1cGRhdGUiIHx8ICRzZWxmLT57cHJvY2Vzc29yfS0+e2FjdGlvbn0gZXEgIm5ld3Nl -YXJjaCIgKSAmJiBkZWZpbmVkICRyZWZpbmVfc2NvbmYgJiYgJHJlZmluZV9zY29uZiBlcSAkZm9y -bWlkICkKCQkJewoJCQkJJG9wdGlvbi0+c2V0QXR0cmlidXRlKCBzZWxlY3RlZCA9PiAic2VsZWN0 -ZWQiICk7CgkJCX0KCgkJCSNzZXQgb3B0aW9uIHRleHQgYW5kIGFkZCB0byBzZWxlY3QKICAJCQkk -b3B0aW9uLT5hcHBlbmRDaGlsZCggJHJlcG9ydF9wbHVnaW4tPnJlbmRlcl90aXRsZSApOwoJCQkk -cmVwb3J0X3NlbGVjdC0+YXBwZW5kQ2hpbGQoICRvcHRpb24gKTsKCgkJCSNjcmVhdGUgc2VhcmNo -IGZvcm0JCQkKCQkJI2dldCByZXBvcnQgZGF0YXNldCBhbmQgYXBwcm9wcmlhdGUgc2VhcmNoIGNv -bmZpZwoJCQlteSAkcmVwb3J0X2RzID0gJHJlcG8tPmRhdGFzZXQoICRyZXBvcnRfcGx1Z2luLT57 -c2VhcmNoZGF0YXNldGlkfSApOwoJCQlteSAkc2NvbmYgPSAkcmVwb3J0X2RzLT5zZWFyY2hfY29u -ZmlnKCAkcmVwb3J0X3BsdWdpbi0+e3Njb25mfSApIDsKCQkJI215ICRzZWFyY2ggPSBFUHJpbnRz -OjpTZWFyY2gtPm5ldygKCQkgICAgICAgICMgICAgICAgIGtlZXBfY2FjaGUgPT4gMSwKCSAgICAg -ICAgICAgICAgICAjCXNlc3Npb24gPT4gJHJlcG8sCgkJICAgICAgICAjICAgICAgICBkYXRhc2V0 -ID0+ICRyZXBvcnRfZHMsCgkJICAgICAgICAjICAgICAgICAleyRzY29uZn0KCQkJIyk7CgoJCQlt -eSAkZm9ybWF0ID0gInJlcG9ydC8iIC4gJHJlcG9ydF9kcy0+YmFzZV9pZDsKCSAgICAgICAgICAg -ICAgICBteSAkc2VhcmNoZXhwID0gJHJlcG8tPnBsdWdpbiggIlNlYXJjaCIgKS0+cGx1Z2lucygK -ICAgICAgICAgICAgICAgICAgICAgICAgCXsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg -ICAJa2VlcF9jYWNoZSA9PiAxLAoJICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzZXNz -aW9uID0+ICRzZWxmLT57c2Vzc2lvbn0sCiAgICAgICAgCSAgICAgICAgICAgICAgICAgICAgICAg -IGRhdGFzZXQgPT4gJHJlcG9ydF9kcywKICAgICAgICAgICAgICAgIAkgICAgICAgICAgICAgICAg -JXskc2NvbmZ9CiAgICAgICAgICAgICAgICAgICAgICAgIAl9LAogICAgICAgICAgICAgICAgICAg -ICAgICB0eXBlID0+ICJTZWFyY2giLAogICAgICAgICAgICAgICAgICAgICAgICBjYW5fc2VhcmNo -ID0+ICRmb3JtYXQsCiAgICAgICAgICAgICAgICAJKTsJCgkJCSRzZWFyY2hleHAtPmZyb21fZm9y -bTsKCgkJCSNnZW5lcmF0ZSB0aGUgZm9ybQoJCQlteSAkZnJhZyA9ICRzZWxmLT5yZW5kZXJfc2Vh -cmNoX2ZpZWxkcyggJHNlYXJjaGV4cCwgJGZvcm1pZCApOwoJCQkkc2VhcmNoX2Zvcm1zeyRmb3Jt -aWR9ID0gJGZyYWcgdW5sZXNzIGV4aXN0cyAkc2VhcmNoX2Zvcm1zeyRmb3JtaWR9OwoJCX0JCgl9 -CgkkZm9ybS0+YXBwZW5kQ2hpbGQoICRyZXBvcnRfc2VsZWN0ICk7CgkkZm9ybS0+YXBwZW5kQ2hp -bGQoICRyZXBvLT5yZW5kZXJfaGlkZGVuX2ZpZWxkKCAic2NyZWVuIiwgJHNlbGYtPntzY3JlZW5p -ZH0gKSApOwoKCSNyZW5kZXIgcG9zc2libGUgc2VhcmNoIGZvcm1zCglmb3JlYWNoIG15ICRmb3Jt -aWQgKGtleXMgJXNlYXJjaF9mb3JtcykKCXsKICAgICAgICAgICAgICAgIG15ICRmaWVsZHNfdGFn -ID0gJHNlYXJjaF9mb3Jtc3skZm9ybWlkfS0+ZmluZG5vZGVzKCd0cicpLT5zaXplID4gMCA/ICJ0 -YWJsZSIgOiAiZGl2IjsKICAgICAgICAgICAgICAgIG15ICRmaWVsZHNfd3JhcHBlciA9ICRyZXBv -LT5tYWtlX2VsZW1lbnQoICRmaWVsZHNfdGFnLCBjbGFzcz0+ImVwX3NlYXJjaF9maWVsZHMiLCBp -ZD0+JGZvcm1pZCwgc3R5bGU9PiJkaXNwbGF5OiBub25lIiApOwogICAgICAgICAgICAgICAgJGZv -cm0tPmFwcGVuZENoaWxkKCAkZmllbGRzX3dyYXBwZXIgKTsKICAgICAgICAgICAgICAgICRmaWVs -ZHNfd3JhcHBlci0+YXBwZW5kQ2hpbGQoICRzZWFyY2hfZm9ybXN7JGZvcm1pZH0gKQoJfQoKCSRm -b3JtLT5hcHBlbmRDaGlsZCggJHNlbGYtPnJlbmRlcl9jb250cm9scyApOwoJJGN1c3RvbS0+YXBw -ZW5kQ2hpbGQoICRmb3JtICk7CgoJI2phdmFzY3JpcHQgZm9yIGNoYW5naW5nIGZvcm1zIGJhc2Vk -IG9uIHJlcG9ydCBzZWxlY3Rpb24KCSRjdXN0b20tPmFwcGVuZENoaWxkKCAkcmVwby0+bWFrZV9q -YXZhc2NyaXB0KCAnaW5pdFJlcG9ydEZvcm0oKTsnICkgKTsKCglpZiggJGN1c3RvbV9yZXBvcnRz -ICYmICRwcmVzZXRzX2FkZGVkID4gMCApICNzZXQgdXAgdGFiIGludGVyZmFjZQoJewoJCW15IEBs -YWJlbHM7CgkgICAgICAgIG15IEBwYW5lbHM7CgoJCXB1c2ggQGxhYmVscywgJHJlcG8tPmh0bWxf -cGhyYXNlKCAicmVwb3J0c19wcmVzZXQiICk7CgkJcHVzaCBAbGFiZWxzLCAkcmVwby0+aHRtbF9w -aHJhc2UoICJyZXBvcnRzX2N1c3RvbSIgKTsKCgkJcHVzaCBAcGFuZWxzLCAkcHJlc2V0OwoJCXB1 -c2ggQHBhbmVscywgJGN1c3RvbTsKCgkJbXkgJW9wdHM7CgkJaWYoICRzZWxmLT57cHJvY2Vzc29y -fS0+e2FjdGlvbn0gZXEgIm5ld3NlYXJjaCIgfHwgJHNlbGYtPntwcm9jZXNzb3J9LT57YWN0aW9u -fSBlcSAidXBkYXRlIiAgKQoJCXsKCQkJJG9wdHN7Y3VycmVudH0gPSAxOwoJCX0KCgkJcmV0dXJu -ICRyZXBvLT54aHRtbC0+dGFicyhcQGxhYmVscywgXEBwYW5lbHMsICVvcHRzICk7Cgl9CgllbHNp -ZiggJHByZXNldHNfYWRkZWQgPiAwICkKCXsJCgkJcmV0dXJuICRwcmVzZXQ7Cgl9CgllbHNlCgl7 -CgkJcmV0dXJuICRjdXN0b207Cgl9Cn0KCnN1YiByZW5kZXJfc2VhcmNoX2ZpZWxkcwp7CiAgICAg -ICAgbXkoICRzZWxmLCAkc2VhcmNoLCAkZm9ybWlkICkgPSBAXzsKCglteSAkZXhwID0gJHNlbGYt -PntzZXNzaW9ufS0+cGFyYW0oICJleHAiICk7CglteSAkc2NvbmYgPSAkc2VsZi0+e3Nlc3Npb259 -LT5wYXJhbSggInNjb25mIiApOwogICAgICAgIGlmKCBkZWZpbmVkICRleHAgJiYgZGVmaW5lZCAk -c2NvbmYgJiYgJHNjb25mIGVxICRmb3JtaWQgKQoJewogICAgICAgICAgICAgICAgJHNlYXJjaC0+ -ZnJvbV9zdHJpbmcoICRleHAgKTsKICAJfQoKICAgICAgICBteSAkZnJhZyA9ICRzZWxmLT57c2Vz -c2lvbn0tPm1ha2VfZG9jX2ZyYWdtZW50OwogICAgICAgIGZvcmVhY2ggbXkgJHNmICggJHNlYXJj -aC0+Z2V0X25vbl9maWx0ZXJfc2VhcmNoZmllbGRzICkKICAgICAgICB7CgkgICAgICAgICAkZnJh -Zy0+YXBwZW5kQ2hpbGQoCiAgICAgICAgICAgICAgICAgICAgICAgICRzZWxmLT57c2Vzc2lvbn0t -PnJlbmRlcl9yb3dfd2l0aF9oZWxwKAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGhl -bHBfcHJlZml4ID0+ICRzZi0+Z2V0X2Zvcm1fcHJlZml4LiJfaGVscCIsCiAgICAgICAgICAgICAg -ICAgICAgICAgICAgICAgICAgaGVscCA9PiAkc2YtPnJlbmRlcl9oZWxwLAogICAgICAgICAgICAg -ICAgICAgICAgICAgICAgICAgIGxhYmVsID0+ICRzZi0+cmVuZGVyX25hbWUsCiAgICAgICAgICAg -ICAgICAgICAgICAgICAgICAgICAgZmllbGQgPT4gJHNmLT5yZW5kZXIsCiAgICAgICAgICAgICAg -ICAgICAgICAgICAgICAgICAgbm9fdG9nZ2xlID0+ICggJHNmLT57c2hvd19oZWxwfSBlcSAiYWx3 -YXlzIiApLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG5vX2hlbHAgPT4gKCAkc2Yt -PntzaG93X2hlbHB9IGVxICJuZXZlciIgKSwKICAgICAgICAJKSApOwogICAgICAgIH0KCiAgICAg -ICAgcmV0dXJuICRmcmFnOwp9CgpzdWIgcmVuZGVyX2NvbnRyb2xzCnsKCW15KCAkc2VsZiwgJHdp -dGhfanMgKSA9IEBfOwoKCW15ICRkaXYgPSAkc2VsZi0+e3Nlc3Npb259LT5tYWtlX2VsZW1lbnQo -CiAgICAgICAgICAgICAgICAiZGl2IiAsCiAgICAgICAgICAgICAgICBjbGFzcyA9PiAiZXBfc2Vh -cmNoX2J1dHRvbnMiICk7CiAgICAgICAgJGRpdi0+YXBwZW5kQ2hpbGQoICRzZWxmLT57c2Vzc2lv -bn0tPnJlbmRlcl9hY3Rpb25fYnV0dG9ucygKICAgICAgICAgICAgICAgIF9vcmRlciA9PiBbICJz -ZWFyY2giIF0sCiAgICAgICAgICAgICAgICAjbmV3c2VhcmNoID0+ICRzZWxmLT57c2Vzc2lvbn0t -PnBocmFzZSggImxpYi9zZWFyY2hleHByZXNzaW9uOmFjdGlvbl9yZXNldCIgKSwKICAgICAgICAg -ICAgICAgIHNlYXJjaCA9PiAkc2VsZi0+e3Nlc3Npb259LT5waHJhc2UoICJsaWIvc2VhcmNoZXhw -cmVzc2lvbjphY3Rpb25fc2VhcmNoIiApICkKICAgICAgICApOwoJCglteSAkeG1sID0gJHNlbGYt -PntzZXNzaW9ufS0+eG1sOwoKCWlmKCAkd2l0aF9qcyApCgl7CgkJbXkgJGNsZWFyX2Zvcm0gPSAk -ZGl2LT5hcHBlbmRDaGlsZCggJHNlbGYtPnJlbmRlcl9jbGVhcmZvcm0oICR4bWwgKSApOwoJfQoK -ICAgICAgICBteSAkY2xlYXJfYnRuID0gJGRpdi0+YXBwZW5kQ2hpbGQoICR4bWwtPmNyZWF0ZV9l -bGVtZW50KCAiYnV0dG9uIiwKICAgICAgICAJdHlwZSA9PiAiYnV0dG9uIiwKICAgICAgICAgICAg -ICAgIG9uY2xpY2sgPT4gImNsZWFyRm9ybSgpOyIsCiAgICAgICAgICAgICAgICBjbGFzcyA9PiAi -ZXBfZm9ybV9hY3Rpb25fYnV0dG9uIGNsZWFyX2J1dHRvbiIsCiAgICAgICAgICAgICAgICApICk7 -CiAgICAgICAgJGNsZWFyX2J0bi0+YXBwZW5kQ2hpbGQoICR4bWwtPmNyZWF0ZV90ZXh0X25vZGUo -ICRzZWxmLT57c2Vzc2lvbn0tPmh0bWxfcGhyYXNlKCAibGliL3NlYXJjaGV4cHJlc3Npb246YWN0 -aW9uX3Jlc2V0IiApICkgKTsKCXJldHVybiAkZGl2Owp9CgpzdWIgcmVuZGVyCnsKCW15KCAkc2Vs -ZiApID0gQF87CgoJIyBpZiB1c2VycyBhY2Nlc3MgU2NyZWVuOjpSZXBvcnQgZGlyZWN0bHkgd2Ug -d2FudCB0byBkaXNwbGF5IHNvbWUgc29ydCBvZiBtZW51CgkjIHdoZXJlIHVzZXJzIGNhbiBzZWxl -Y3Qgdmlld2FibGUgcmVwb3J0cwoJaWYoICggIkVQcmludHM6OlBsdWdpbjo6Ii4kc2VsZi0+Z2V0 -X2lkIGVxIF9fUEFDS0FHRV9fICYmICRzZWxmLT57cHJvY2Vzc29yfS0+e2FjdGlvbn0gbmUgInNl -YXJjaCIgKSB8fCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPnthY3Rpb259IGVxICJuZXdzZWFyY2giICkK -CXsJCgkJcmV0dXJuICRzZWxmLT5yZW5kZXJfc3BsYXNoX3BhZ2U7Cgl9CgoJbXkgJHJlcG8gPSAk -c2VsZi0+cmVwb3NpdG9yeTsKCglteSAkY2h1bmsgPSAkcmVwby0+bWFrZV9kb2NfZnJhZ21lbnQ7 -CgoJJGNodW5rLT5hcHBlbmRDaGlsZCggJHNlbGYtPnJlbmRlcl9leHBvcnRfYmFyICk7CgkkY2h1 -bmstPmFwcGVuZENoaWxkKCAkc2VsZi0+cmVuZGVyX2dyb3VwX29wdGlvbnMgKTsKCSRjaHVuay0+ -YXBwZW5kQ2hpbGQoICRzZWxmLT5yZW5kZXJfc29ydF9vcHRpb25zICk7CgoJaWYoICRzZWxmLT57 -cHJvY2Vzc29yfS0+e2FjdGlvbn0gZXEgInNlYXJjaCIgKQoJewoJCSRjaHVuay0+YXBwZW5kQ2hp -bGQoICRzZWxmLT5yZW5kZXJfcmVmaW5lX3NlYXJjaCApOwoJfQoKCW15ICRpdGVtcyA9ICRzZWxm -LT5pdGVtczsKCWlmKCAhZGVmaW5lZCAkaXRlbXMgfHwgJGl0ZW1zLT5jb3VudCA9PSAwICkKCXsK -CQkjIE5vIGl0ZW1zIG1lc3NhZ2UKCX0KCglteSAkanNvbjsKCglpZiggZGVmaW5lZCAkc2VsZi0+ -e3Byb2Nlc3Nvcn0tPntncm91cH0gJiYgJHNlbGYtPntwcm9jZXNzb3J9LT57Z3JvdXB9IG5lICIi -ICkKCXsKCQlteSAkZ3JvdXBlZCA9ICRzZWxmLT5nZXRfZ3JvdXBlZF9pdGVtcyggJGl0ZW1zLCAx -ICk7CgkJJGpzb24gPSBlbmNvZGVfanNvbiAkZ3JvdXBlZDsKCX0KCWVsc2UKCXsKCQlteSAkaXRl -bV9pZHMgPSBkZWZpbmVkICRpdGVtcyA/ICRpdGVtcy0+aWRzIDogW107CgkJJGpzb24gPSAiWyIu -am9pbignLCcsQCRpdGVtX2lkcykuIl0iOwoJfQoKICAgICAgICBteSAkdXJsID0gJHJlcG8tPmN1 -cnJlbnRfdXJsKCBob3N0ID0+IDEgKTsKICAgICAgICBteSAkcGFyYW1ldGVycyA9IFVSSS0+bmV3 -OwogICAgICAgICRwYXJhbWV0ZXJzLT5xdWVyeV9mb3JtKAogICAgICAgICAgICAgICAgJHNlbGYt -PmhpZGRlbl9iaXRzLAogICAgICAgICk7CiAgICAgICAgJHBhcmFtZXRlcnMgPSAkcGFyYW1ldGVy -cy0+cXVlcnk7CgkJCglteSAkZHMgPSAkcmVwby0+ZGF0YXNldCggJHNlbGYtPnBhcmFtKCAnZGF0 -YXNldGlkJyApICkgaWYgZGVmaW5lZCAkc2VsZi0+cGFyYW0oICdkYXRhc2V0aWQnICk7CglteSAk -cHJlZml4ID0gJGRzLT5iYXNlX2lkIGlmIGRlZmluZWQgJGRzOwoKCSMgdGhlIG1haW4gPGRpdj4K -CW15ICRjb250YWluZXJfaWQgPSBzcHJpbnRmKCAiZXBfcmVwb3J0XyVzXF9jb250YWluZXIiLCAk -c2VsZi0+Z2V0X3JlcG9ydCApOwoKCSN1cGRhdGUgamF2YXNjcmlwdCBwYXJhbWV0ZXJzIGlmIGNv -bWluZyBmcm9tIGEgc2VhcmNoIHJlcXVlc3QKCWlmKCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPnthY3Rp -b259IGVxICJzZWFyY2giICkKCXsKCQlteSAkcGx1Z2luID0gJHNlbGYtPntwcm9jZXNzb3J9LT57 -cmVwb3J0fTsKCQkkcGx1Z2luID1+IHMvOi8lM0EvZzsKCQkkcGFyYW1ldGVycyA9ICJzY3JlZW49 -JHBsdWdpbiI7CgkJJHByZWZpeCA9ICRzZWxmLT57cHJvY2Vzc29yfS0+e2RhdGFzZXRpZH07CgkJ -JGNvbnRhaW5lcl9pZCA9IHNwcmludGYoICJlcF9yZXBvcnRfJXNcX2NvbnRhaW5lciIsICRzZWxm -LT57cHJvY2Vzc29yfS0+e3JlcG9ydF9wbHVnaW59LT57cmVwb3J0fSApOwoJfQoJCgkjc2hvdy9o -aWRlIGNvbXBsaWFuY2UKCW15ICRzaG93X2NvbXBsaWFuY2UgPSAxOwoJJHNob3dfY29tcGxpYW5j -ZSA9ICRzZWxmLT57c2hvd19jb21wbGlhbmNlfSBpZiBkZWZpbmVkICRzZWxmLT57c2hvd19jb21w -bGlhbmNlfTsKCgkjY3VzdG9tIGxhYmVscwoJbXkgJGxhYmVscyA9IDA7CgkkbGFiZWxzID0gZW5j -b2RlX2pzb24gJHNlbGYtPntsYWJlbHN9IGlmIGRlZmluZWQgJHNlbGYtPntsYWJlbHN9OwoKCSRj -aHVuay0+YXBwZW5kQ2hpbGQoICRyZXBvLT5tYWtlX2phdmFzY3JpcHQoIDw8IkVPSiIgKSApOwpk -b2N1bWVudC5vYnNlcnZlKCJkb206bG9hZGVkIiwgZnVuY3Rpb24oKSB7CgluZXcgRVByaW50c19T -Y3JlZW5fUmVwb3J0X0xvYWRlciggewoJCWlkczogJGpzb24sCgkJcHJlZml4OiAnJHByZWZpeCcs -CgkJdXJsOiAnJHVybCcsCgkJcGFyYW1ldGVyczogJyRwYXJhbWV0ZXJzJywJCQoJCWNvbnRhaW5l -cl9pZDogJyRjb250YWluZXJfaWQnLAoJCXNob3dfY29tcGxpYW5jZTogJHNob3dfY29tcGxpYW5j -ZSwKCQlsYWJlbHM6ICRsYWJlbHMKCX0gKS5leGVjdXRlKCk7Cgp9KTsKRU9KCgkkY2h1bmstPmFw -cGVuZENoaWxkKCAkcmVwby0+bWFrZV9lbGVtZW50KCAnZGl2JywgY2xhc3MgPT4gJ2VwX3JlcG9y -dF9wYWdlJywgaWQgPT4gJGNvbnRhaW5lcl9pZCApICk7CgoJI3Nob3cgc2VhcmNoIGNvbnRyb2xz -IGFmdGVyIHRoZSByZXN1bHRzIHRvbwoJaWYoICRzZWxmLT57cHJvY2Vzc29yfS0+e2FjdGlvbn0g -ZXEgInNlYXJjaCIgKQogICAgICAgIHsKICAgICAgICAgICAgICAgICRjaHVuay0+YXBwZW5kQ2hp -bGQoICRzZWxmLT5yZW5kZXJfcmVmaW5lX3NlYXJjaCApOwogICAgICAgIH0KCglyZXR1cm4gJGNo -dW5rOwp9CgoKc3ViIHJlbmRlcl9leHBvcnRfYmFyCnsKCW15KCAkc2VsZiApID0gQF87CgoJbXkg -JHJlcG8gPSAkc2VsZi0+cmVwb3NpdG9yeTsKCglteSAkY2h1bmsgPSAkcmVwby0+bWFrZV9kb2Nf -ZnJhZ21lbnQ7CgoJbXkgQHBsdWdpbnMgPSAkc2VsZi0+ZXhwb3J0X3BsdWdpbnM7CglyZXR1cm4g -JGNodW5rIHVubGVzcyggc2NhbGFyKCBAcGx1Z2lucyApIHx8IGRlZmluZWQoICRyZXBvLT5jb25m -aWcoICRzZWxmLT57ZXhwb3J0X2NvbmZ9LCAiZXhwb3J0ZmllbGRzIiApICkgKTsKCglteSAkcmVw -b3J0X2RzID0gJHJlcG8tPmRhdGFzZXQoICRzZWxmLT57ZGF0YXNldGlkfSApOwoJbXkgJGZvcm0g -PSAkc2VsZi0+cmVuZGVyX2Zvcm07CgkkZm9ybS0+c2V0QXR0cmlidXRlKCBtZXRob2QgPT4gImdl -dCIgKTsKCglpZiggZGVmaW5lZCAkc2VsZi0+cmVwb3NpdG9yeS0+cGFyYW0oICJzZWFyY2giICkg -fHwgJHNlbGYtPntwcm9jZXNzb3J9LT57YWN0aW9ufSBlcSAic2VhcmNoIiApCgl7CgkJJGZvcm0t -PmFwcGVuZENoaWxkKCAkcmVwby0+cmVuZGVyX2hpZGRlbl9maWVsZCggInNlYXJjaCIsICAkc2Vs -Zi0+e3Byb2Nlc3Nvcn0tPntzZWFyY2h9LT5zZXJpYWxpc2UpICk7Cgl9CgkJCglpZiggZGVmaW5l -ZCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntzb3J0fSApCgl7CgkJJGZvcm0tPmFwcGVuZENoaWxkKCAk -cmVwby0+cmVuZGVyX2hpZGRlbl9maWVsZCggInNvcnQiLCAgJHNlbGYtPntwcm9jZXNzb3J9LT57 -c29ydH0gKSApOwoJfQkKCglpZiggZGVmaW5lZCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntncm91cF9l -eHB9ICkKCXsKCQkkZm9ybS0+YXBwZW5kQ2hpbGQoICRyZXBvLT5yZW5kZXJfaGlkZGVuX2ZpZWxk -KCAiZ3JvdXAiLCAgJHNlbGYtPntwcm9jZXNzb3J9LT57Z3JvdXBfZXhwfSApICk7Cgl9CQoKCWlm -KCAhZGVmaW5lZCggJHJlcG8tPmNvbmZpZyggJHNlbGYtPntleHBvcnRfY29uZn0sICJleHBvcnRm -aWVsZHMiICkgKSApCgl7CgkJI25vIGN1c3RvbSBleHBvcnQgZmllbGRzIGRlZmluZWQsIHVzZSBl -eHBvcnQgcGx1Z2lucyBkZXNpZ25lZCBmb3IgdGhpcyByZXBvcnQKCQlteSAkc2VsZWN0ID0gJGZv -cm0tPmFwcGVuZENoaWxkKCAkcmVwby0+cmVuZGVyX29wdGlvbl9saXN0KAoJCQluYW1lID0+ICdl -eHBvcnQnLAoJCQl2YWx1ZXMgPT4gW21hcCB7ICRfLT5nZXRfc3VidHlwZSB9IEBwbHVnaW5zXSwK -CQkJbGFiZWxzID0+IHttYXAgeyAkXy0+Z2V0X3N1YnR5cGUgPT4gJF8tPmdldF9uYW1lIH0gQHBs -dWdpbnN9LAoJCSkgKTsKCX0KCWVsc2UKCXsKCQkjcHJvdmlkZSBsaXN0IG9mIGRlZmF1bHQgZXhw -b3J0IHBsdWdpbnMgZm9yIHJlcG9ydHMKCQlAcGx1Z2lucyA9ICRzZWxmLT5leHBvcnRfcGx1Z2lu -cyggImdlbmVyaWMiICk7CgkJbXkgJHNlbGVjdCA9ICRmb3JtLT5hcHBlbmRDaGlsZCggJHJlcG8t -PnJlbmRlcl9vcHRpb25fbGlzdCgKCQkJbmFtZSA9PiAnZXhwb3J0JywKCQkJdmFsdWVzID0+IFtt -YXAgeyAkXy0+Z2V0X3N1YnR5cGUgfSBAcGx1Z2luc10sCgkJCWxhYmVscyA9PiB7bWFwIHsgJF8t -PmdldF9zdWJ0eXBlID0+ICRfLT5nZXRfbmFtZSB9IEBwbHVnaW5zfSwKCQkpICk7CgoJCSNjcmVh -dGUgbGFiZWxzIGFuZCBwYW5lbHMgZm9yIHRhYmJlZCBpbnRlcmZhY2VkCgkJbXkgJHhtbCA9ICRy -ZXBvLT54bWw7CgkJbXkgJHhodG1sID0gJHJlcG8tPnhodG1sOwoKCQlteSAkc2VsZWN0X2FsbCA9 -ICRmb3JtLT5hcHBlbmRDaGlsZCggJHNlbGYtPnJlbmRlcl9zZWxlY3RhbGwoICR4bWwgKSApOwoJ -CW15ICRzZWxlY3RfYnRuID0gJGZvcm0tPmFwcGVuZENoaWxkKCAkeG1sLT5jcmVhdGVfZWxlbWVu -dCggImJ1dHRvbiIsCgkgICAgICAgICAgICAgICAgICAgIHR5cGUgPT4gImJ1dHRvbiIsCgkgICAg -ICAgICAgICAgICAgICAgIG9uY2xpY2sgPT4gInRvZ2dsZUNoZWNrYm94ZXMoKTsiLAoJICAgICAg -ICAgICAgICAgICAgICBjbGFzcyA9PiAiZXBfZm9ybV9hY3Rpb25fYnV0dG9uIHNlbGVjdF9idXR0 -b24iLAoJCSkgKTsKCSAgICAJJHNlbGVjdF9idG4tPmFwcGVuZENoaWxkKCAkeG1sLT5jcmVhdGVf -dGV4dF9ub2RlKCAkcmVwby0+aHRtbF9waHJhc2UoICJyZXBvcnRfc2VsZWN0IiApICkgKTsKCgkJ -I2FsbG93IHVzZXIgdG8gY2hvb3NlIHdoaWNoIGZpZWxkcyB0aGV5IHdhbnQgdG8gZXhwb3J0CgkJ -bXkgJGV4cG9ydF9vcHRpb25zID0gJHJlcG8tPm1ha2VfZWxlbWVudCggImRpdiIgKTsKCgkJbXkg -QGtleXM7CgkJaWYoIGRlZmluZWQgJHJlcG8tPmNvbmZpZyggJHNlbGYtPntleHBvcnRfY29uZn0s -ICJleHBvcnRmaWVsZF9vcmRlciIgKSApCgkJewoJCQlAa2V5cyA9IEB7JHJlcG8tPmNvbmZpZygg -JHNlbGYtPntleHBvcnRfY29uZn0sICJleHBvcnRmaWVsZF9vcmRlciIgKX07CgkJfQoJCWVsc2UK -CQl7CgkJCUBrZXlzID0ga2V5cyAleyRyZXBvLT5jb25maWcoICRzZWxmLT57ZXhwb3J0X2NvbmZ9 -LCAiZXhwb3J0ZmllbGRzIiApfTsgCgkJfQoJCWZvcmVhY2ggbXkgJGtleSAoIEBrZXlzICkKCQl7 -CgkJCSNjcmVhdGUgYSBuZXcgbGlzdAkJCQoJCQlteSAkdWwgPSAkcmVwby0+bWFrZV9lbGVtZW50 -KCAidWwiLAoJICAgICAgICAgICAgICAgIAlzdHlsZSA9PiAibGlzdC1zdHlsZS10eXBlOiBub25l -IgoJICAgICAgICAJKTsKCQkJCgkJCW15ICRjb3VudCA9IDA7ICNjb3VudCBob3cgbWFueSBmaWVs -ZHMgd2UgYWRkCgkJCWZvcmVhY2ggbXkgJGZpZWxkbmFtZSggQHskcmVwby0+Y29uZmlnKCAkc2Vs -Zi0+e2V4cG9ydF9jb25mfSwgImV4cG9ydGZpZWxkcyIgKS0+eyRrZXl9fSApCgkJCXsKCQkJCWlm -KCBkZWZpbmVkICRyZXBvLT5jb25maWcoICRzZWxmLT57ZXhwb3J0X2NvbmZ9LCAiY3VzdG9tX2V4 -cG9ydCIgKSAmJiBleGlzdHMgJHskcmVwby0+Y29uZmlnKCAkc2VsZi0+e2V4cG9ydF9jb25mfSwg -ImN1c3RvbV9leHBvcnQiICl9eyRmaWVsZG5hbWV9ICkgI3dlIGhhdmUgYSBjdXN0b20gZXhwb3J0 -IGZ1bmN0aW9uIGluc3RlYWQgCgkJCQl7CgkJCQkJJGNvdW50Kys7CgkJCQkJJHNlbGYtPl9leHBv -cnRfZmllbGRfY2hlY2tib3goICRyZXBvLCAkZmllbGRuYW1lLCAkdWwsICRyZXBvLT5odG1sX3Bo -cmFzZSggImV4cG9ydGZpZWxkb3B0aW9uczokZmllbGRuYW1lIiApICk7IAoJCQkJfQoJCQkJZWxz -aWYoIGRlZmluZWQgRVByaW50czo6VXRpbHM6OmZpZWxkX2Zyb21fY29uZmlnX3N0cmluZyggJHJl -cG9ydF9kcywgJGZpZWxkbmFtZSApICkKCQkJCXsKCQkJCQlteSAkZmllbGQgPSBFUHJpbnRzOjpV -dGlsczo6ZmllbGRfZnJvbV9jb25maWdfc3RyaW5nKCAkcmVwb3J0X2RzLCAkZmllbGRuYW1lICk7 -CgkJCQkJJGNvdW50Kys7CiAgICAgICAJCQkgICAgICAgIAkkc2VsZi0+X2V4cG9ydF9maWVsZF9j -aGVja2JveCggJHJlcG8sICRmaWVsZG5hbWUsICR1bCwgJGZpZWxkLT5yZW5kZXJfbmFtZSApOwoK -CQkJCX0KCQkJfQoJCQlpZiggJGNvdW50ICkgI29ubHkgYWRkIG9wdGlvbnMgaWYgd2UgaGF2ZSBh -bnkgZmllbGRzIHRvIHNob3cKCQkJewoJCQkJbXkgJGRpdiA9ICRyZXBvLT5tYWtlX2VsZW1lbnQo -ICJkaXYiLCBjbGFzcz0+InJlcG9ydF9leHBvcnRfb3B0aW9ucyIgKTsKCQkJCSRkaXYtPmFwcGVu -ZENoaWxkKCBteSAkaCA9ICRyZXBvLT5tYWtlX2VsZW1lbnQoICJoNCIgKSApOwoJCQkJJGgtPmFw -cGVuZENoaWxkKCAkcmVwby0+aHRtbF9waHJhc2UoICJleHBvcnRmaWVsZHM6JGtleSIgKSApOwkK -CQkJCSRkaXYtPmFwcGVuZENoaWxkKCAkdWwgKTsKCQkJCSRleHBvcnRfb3B0aW9ucy0+YXBwZW5k -Q2hpbGQoICRkaXYgKTsKCQkJfQogICAgICAgCQl9CgkJJGZvcm0tPmFwcGVuZENoaWxkKCAkZXhw -b3J0X29wdGlvbnMgKTsKCX0KCgkkZm9ybS0+YXBwZW5kQ2hpbGQoIAoJCSRyZXBvLT5yZW5kZXJf -YnV0dG9uKAoJCQluYW1lID0+ICJfYWN0aW9uX2V4cG9ydCIsCgkJCWNsYXNzID0+ICJlcF9mb3Jt -X2FjdGlvbl9idXR0b24iLAoJCQl2YWx1ZSA9PiAkcmVwby0+cGhyYXNlKCAnY2dpL3VzZXJzL2Vk -aXRfZXByaW50OmV4cG9ydCcgKQoJKSApOwoKCSNjcmVhdGUgYSBjb2xsYXBzaWJsZSBib3gKCW15 -ICRpbWFnZXN1cmwgPSAkcmVwby0+Y3VycmVudF91cmwoIHBhdGggPT4gInN0YXRpYyIsICJzdHls -ZS9pbWFnZXMiICk7CglteSAlb3B0aW9uczsKCSRvcHRpb25ze3Nlc3Npb259ID0gJHJlcG87CiAg -ICAgICAgJG9wdGlvbnN7aWR9ID0gImVwX3JlcG9ydF9leHBvcnQiOwogICAgICAgICRvcHRpb25z -e3RpdGxlfSA9ICRyZXBvLT5odG1sX3BocmFzZSggImV4cG9ydF90aXRsZSIgKTsKICAgICAgICAk -b3B0aW9uc3tjb2xsYXBzZWR9ID0gMTsKCSRvcHRpb25ze2NvbnRlbnR9ID0gJGZvcm07CiAgICAg -ICAgJG9wdGlvbnN7c2hvd19pY29uX3VybH0gPSAiJGltYWdlc3VybC9tdWx0aV9kb3duLnBuZyI7 -Cgkkb3B0aW9uc3toaWRlX2ljb25fdXJsfSA9ICIkaW1hZ2VzdXJsL211bHRpX3VwLnBuZyI7CgoJ -bXkgJGJveCA9ICRyZXBvLT5tYWtlX2VsZW1lbnQoICJkaXYiLCBzdHlsZT0+InRleHQtYWxpZ246 -IGxlZnQiICk7CgkkYm94LT5hcHBlbmRDaGlsZCggRVByaW50czo6Qm94OjpyZW5kZXIoICVvcHRp -b25zICkgKTsKCSRjaHVuay0+YXBwZW5kQ2hpbGQoICRib3ggKTsKCglyZXR1cm4gJGNodW5rOwp9 -CgpzdWIgcmVuZGVyX3NvcnRfb3B0aW9ucwp7CglteSggJHNlbGYgKSA9IEBfOwoKCW15ICRyZXBv -ID0gJHNlbGYtPnJlcG9zaXRvcnk7CgoJbXkgJGNodW5rID0gJHJlcG8tPm1ha2VfZG9jX2ZyYWdt -ZW50OwoKCXJldHVybiAkY2h1bmsgdW5sZXNzKCBkZWZpbmVkKCAkcmVwby0+Y29uZmlnKCAkc2Vs -Zi0+e3NvcnRfY29uZn0sICJzb3J0ZmllbGRzIiApICkgKTsKCglteSAkc29ydF9jb25mID0gJHJl -cG8tPmNvbmZpZyggJHNlbGYtPntzb3J0X2NvbmZ9LCAic29ydGZpZWxkcyIgKTsKCgkjYnVpbGQg -dGhlIGZvcm0KCW15ICRmb3JtID0gJHNlbGYtPnJlbmRlcl9mb3JtOwoJJGZvcm0tPnNldEF0dHJp -YnV0ZSggbmFtZSA9PiAic29ydF9yZXBvcnQiICk7CiAgICAgICAgJGZvcm0tPnNldEF0dHJpYnV0 -ZSggbWV0aG9kID0+ICJnZXQiICk7CgkkY2h1bmstPmFwcGVuZENoaWxkKCAkZm9ybSApOwoJCglp -ZiggZGVmaW5lZCAkcmVwby0+cGFyYW0oICJzZWFyY2giICkgfHwgJHNlbGYtPntwcm9jZXNzb3J9 -LT57YWN0aW9ufSBlcSAic2VhcmNoIiApCgl7CgkJJGZvcm0tPmFwcGVuZENoaWxkKCAkcmVwby0+ -cmVuZGVyX2hpZGRlbl9maWVsZCggInNlYXJjaCIsICAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntzZWFy -Y2h9LT5zZXJpYWxpc2UpICk7Cgl9CgoJaWYoIGRlZmluZWQgJHNlbGYtPntwcm9jZXNzb3J9LT57 -Z3JvdXBfZXhwfSApCgl7CgkJJGZvcm0tPmFwcGVuZENoaWxkKCAkcmVwby0+cmVuZGVyX2hpZGRl -bl9maWVsZCggImdyb3VwIiwgICRzZWxmLT57cHJvY2Vzc29yfS0+e2dyb3VwX2V4cH0gKSApOwoJ -fQoKCSNkaXNwbGF5IHRoZSBsaW5rcyB0aGF0IHdpbGwgdHJpZ2dlciB0aGUgZm9ybQoJbXkgJGZp -cnN0ID0gMTsKCW15ICRzb3J0X2xpbmtzID0gJHJlcG8tPm1ha2VfZG9jX2ZyYWdtZW50OwoJZm9y -ZWFjaCBteSAkc29ydF9uYW1lICgga2V5cyAleyRzb3J0X2NvbmZ9ICkKICAgICAgICB7CgkJbXkg -JHNvcnRfdmFsdWUgPSAkc29ydF9jb25mLT57JHNvcnRfbmFtZX07CgkJaWYoICRmaXJzdCApCgkJ -ewoJCQkkZm9ybS0+YXBwZW5kQ2hpbGQoICRyZXBvLT5yZW5kZXJfaGlkZGVuX2ZpZWxkKCAic29y -dCIsICRzb3J0X3ZhbHVlKSApOwoJCX0KCgkJaWYoICEkZmlyc3QgKQogICAgICAgICAgICAgICAg -ewogICAgICAgICAgICAgICAgCSRzb3J0X2xpbmtzLT5hcHBlbmRDaGlsZCggJHJlcG8tPmh0bWxf -cGhyYXNlKCAiVXBkYXRlL1ZpZXdzOmdyb3VwX3NlcGFyYXRvciIgKSApOwogICAgICAgICAgICAg -ICAgfQoJCQoJCWlmKCBkZWZpbmVkICRzZWxmLT57cHJvY2Vzc29yfS0+e3NvcnR9ICYmICRzZWxm -LT57cHJvY2Vzc29yfS0+e3NvcnR9IGVxICRzb3J0X3ZhbHVlICkKCQl7CgkJCW15ICRzdHJvbmcg -PSAkcmVwby0+bWFrZV9lbGVtZW50KCAic3Ryb25nIiApOwoJCQkkc3Ryb25nLT5hcHBlbmRDaGls -ZCggJHJlcG8tPmh0bWxfcGhyYXNlKCAkc2VsZi0+e3NvcnRfY29uZn0gLiAiOnNvcnQ6IiAuICRz -b3J0X25hbWUgKSApOwoJCQkkc29ydF9saW5rcy0+YXBwZW5kQ2hpbGQoICRzdHJvbmcgKTsKCQl9 -CgkJZWxzZQoJCXsKCQkJbXkgJGxpbmsgPSAkcmVwby0+cmVuZGVyX2xpbmsoICdqYXZhc2NyaXB0 -OnNvcnRfcmVwb3J0KCInLiRzb3J0X3ZhbHVlLiciKScgKTsJCgkJCSRsaW5rLT5hcHBlbmRDaGls -ZCggJHJlcG8tPmh0bWxfcGhyYXNlKCAkc2VsZi0+e3NvcnRfY29uZn0gLiAiOnNvcnQ6IiAuICRz -b3J0X25hbWUgKSApOwoJCQkkc29ydF9saW5rcy0+YXBwZW5kQ2hpbGQoICRsaW5rICk7CgkJfQoJ -CSRmaXJzdCA9IDA7CiAgICAgICAgfSAgICAgICAgICAgCgkkY2h1bmstPmFwcGVuZENoaWxkKCAk -cmVwby0+aHRtbF9waHJhc2UoICJSZXBvcnQ6c29ydF9saW5rcyIsIGxpbmtzPT4kc29ydF9saW5r -cyApICk7CglyZXR1cm4gJGNodW5rOwp9CgpzdWIgcmVuZGVyX2dyb3VwX29wdGlvbnMKewoJbXko -ICRzZWxmICkgPSBAXzsKCglteSAkcmVwbyA9ICRzZWxmLT5yZXBvc2l0b3J5OwoKCW15ICRjaHVu -ayA9ICRyZXBvLT5tYWtlX2RvY19mcmFnbWVudDsKCglyZXR1cm4gJGNodW5rIHVubGVzcyggZGVm -aW5lZCggJHJlcG8tPmNvbmZpZyggJHNlbGYtPntncm91cF9jb25mfSwgImdyb3VwZmllbGRzIiAp -ICkgKTsKCglteSAkZ3JvdXBfY29uZiA9ICRyZXBvLT5jb25maWcoICRzZWxmLT57Z3JvdXBfY29u -Zn0sICJncm91cGZpZWxkcyIgKTsKCgkjYnVpbGQgdGhlIGZvcm0KCW15ICRmb3JtID0gJHNlbGYt -PnJlbmRlcl9mb3JtOwoJJGZvcm0tPnNldEF0dHJpYnV0ZSggbmFtZSA9PiAiZ3JvdXBfcmVwb3J0 -IiApOwogICAgICAgICRmb3JtLT5zZXRBdHRyaWJ1dGUoIG1ldGhvZCA9PiAiZ2V0IiApOwoJJGNo -dW5rLT5hcHBlbmRDaGlsZCggJGZvcm0gKTsKCQoJaWYoIGRlZmluZWQgJHJlcG8tPnBhcmFtKCAi -c2VhcmNoIiApIHx8ICRzZWxmLT57cHJvY2Vzc29yfS0+e2FjdGlvbn0gZXEgInNlYXJjaCIgKQoJ -ewoJCSRmb3JtLT5hcHBlbmRDaGlsZCggJHJlcG8tPnJlbmRlcl9oaWRkZW5fZmllbGQoICJzZWFy -Y2giLCAgJHNlbGYtPntwcm9jZXNzb3J9LT57c2VhcmNofS0+c2VyaWFsaXNlKSApOwoJfQoKCWlm -KCBkZWZpbmVkICRzZWxmLT57cHJvY2Vzc29yfS0+e3NvcnR9ICkKCXsKCQkkZm9ybS0+YXBwZW5k -Q2hpbGQoICRyZXBvLT5yZW5kZXJfaGlkZGVuX2ZpZWxkKCAic29ydCIsICAkc2VsZi0+e3Byb2Nl -c3Nvcn0tPntzb3J0fSApICk7Cgl9CgoJI2Rpc3BsYXkgdGhlIGxpbmtzIHRoYXQgd2lsbCB0cmln -Z2VyIHRoZSBmb3JtCglteSAkZmlyc3QgPSAxOwoJbXkgJGdyb3VwX2xpbmtzID0gJHJlcG8tPm1h -a2VfZG9jX2ZyYWdtZW50OwoJZm9yZWFjaCBteSAkZ3JvdXBfdmFsdWUgKCBAeyRncm91cF9jb25m -fSApCiAgICAgICAgewoJCW15ICgkZ3JvdXBfZmllbGQpID0gc3BsaXQoLzsvLCAkZ3JvdXBfdmFs -dWUgKTsKCQlpZiggJGZpcnN0ICkKCQl7CgkJCSRmb3JtLT5hcHBlbmRDaGlsZCggJHJlcG8tPnJl -bmRlcl9oaWRkZW5fZmllbGQoICJncm91cCIsICRncm91cF92YWx1ZSkgKTsKCQl9CgoJCWlmKCAh -JGZpcnN0ICkKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIAkkZ3JvdXBfbGlua3Mt -PmFwcGVuZENoaWxkKCAkcmVwby0+aHRtbF9waHJhc2UoICJVcGRhdGUvVmlld3M6Z3JvdXBfc2Vw -YXJhdG9yIiApICk7CiAgICAgICAgICAgICAgICB9CgkJCgkJaWYoIGRlZmluZWQgJHNlbGYtPntw -cm9jZXNzb3J9LT57Z3JvdXB9ICYmICRzZWxmLT57cHJvY2Vzc29yfS0+e2dyb3VwfSBlcSAkZ3Jv -dXBfZmllbGQgKQoJCXsKCQkJbXkgJHN0cm9uZyA9ICRyZXBvLT5tYWtlX2VsZW1lbnQoICJzdHJv -bmciICk7CgkJCSRzdHJvbmctPmFwcGVuZENoaWxkKCAkcmVwby0+aHRtbF9waHJhc2UoICRzZWxm -LT57Z3JvdXBfY29uZn0gLiAiOmdyb3VwOiIgLiAkZ3JvdXBfZmllbGQgKSApOwoJCQkkZ3JvdXBf -bGlua3MtPmFwcGVuZENoaWxkKCAkc3Ryb25nICk7CgkJfQoJCWVsc2UKCQl7CgkJCW15ICRsaW5r -ID0gJHJlcG8tPnJlbmRlcl9saW5rKCAnamF2YXNjcmlwdDpncm91cF9yZXBvcnQoIicuJGdyb3Vw -X3ZhbHVlLiciKScgKTsJCgkJCSRsaW5rLT5hcHBlbmRDaGlsZCggJHJlcG8tPmh0bWxfcGhyYXNl -KCAkc2VsZi0+e2dyb3VwX2NvbmZ9IC4gIjpncm91cDoiIC4gJGdyb3VwX2ZpZWxkICkgKTsKCQkJ -JGdyb3VwX2xpbmtzLT5hcHBlbmRDaGlsZCggJGxpbmsgKTsKCQl9CgkJJGZpcnN0ID0gMDsKICAg -ICAgICB9ICAgICAgICAgICAKCQoJI25vIGdyb3VwaW5nIGxpbmsgYXQgdGhlIGVuZAoJJGdyb3Vw -X2xpbmtzLT5hcHBlbmRDaGlsZCggJHJlcG8tPmh0bWxfcGhyYXNlKCAiVXBkYXRlL1ZpZXdzOmdy -b3VwX3NlcGFyYXRvciIgKSApOwoJaWYoIGRlZmluZWQgJHNlbGYtPntwcm9jZXNzb3J9LT57Z3Jv -dXB9ICYmICRzZWxmLT57cHJvY2Vzc29yfS0+e2dyb3VwfSBuZSAiIiApCgl7CgkJbXkgJGxpbmsg -PSAkcmVwby0+cmVuZGVyX2xpbmsoICdqYXZhc2NyaXB0Omdyb3VwX3JlcG9ydCgiIiknICk7CQoJ -CSRsaW5rLT5hcHBlbmRDaGlsZCggJHJlcG8tPmh0bWxfcGhyYXNlKCAicmVwb3J0Om5vX2dyb3Vw -aW5nIiApICk7CgkJJGdyb3VwX2xpbmtzLT5hcHBlbmRDaGlsZCggJGxpbmsgKTsKCX0KCWVsc2UK -CXsKCQlteSAkc3Ryb25nID0gJHJlcG8tPm1ha2VfZWxlbWVudCggInN0cm9uZyIgKTsKIAkJJHN0 -cm9uZy0+YXBwZW5kQ2hpbGQoICRyZXBvLT5odG1sX3BocmFzZSggInJlcG9ydDpub19ncm91cGlu -ZyIgKSApOwoJCSRncm91cF9saW5rcy0+YXBwZW5kQ2hpbGQoICRzdHJvbmcgKTsKCX0KCQoJJGNo -dW5rLT5hcHBlbmRDaGlsZCggJHJlcG8tPmh0bWxfcGhyYXNlKCAiUmVwb3J0Omdyb3VwX2xpbmtz -IiwgbGlua3M9PiRncm91cF9saW5rcyApICk7CgoJcmV0dXJuICRjaHVuazsKfQoKc3ViIHJlbmRl -cl9yZWZpbmVfc2VhcmNoCnsKCW15KCAkc2VsZiApID0gQF87CgoJbXkgJHJlcG8gPSAkc2VsZi0+ -cmVwb3NpdG9yeTsKCglteSAkY2h1bmsgPSAkcmVwby0+bWFrZV9kb2NfZnJhZ21lbnQ7CgkKCWlm -KCBkZWZpbmVkICRyZXBvLT5wYXJhbSggInNlYXJjaCIgKSB8fCAkc2VsZi0+e3Byb2Nlc3Nvcn0t -PnthY3Rpb259IGVxICJzZWFyY2giICkKCXsKCQlteSAkZXNjZXhwID0gJHNlbGYtPntwcm9jZXNz -b3J9LT57c2VhcmNofS0+c2VyaWFsaXNlOwoJCW15ICRjYWNoZWlkID0gJHJlcG8tPnBhcmFtKCAi -Y2FjaGUiICk7CgkJbXkgJHNjb25mID0gJHNlbGYtPntzY29uZn07CQoKCQkjc2V0IHVwIG5ldyBz -ZWFyY2ggbGluawoJCW15ICRuZXdfYmFzZXVybCA9IFVSSS0+bmV3KCAkc2VsZi0+e3Nlc3Npb259 -LT5nZXRfdXJpICk7CiAgICAgICAgCSRuZXdfYmFzZXVybC0+cXVlcnlfZm9ybSgKCSAgICAgICAg -ICAgICAgICBzY3JlZW4gPT4gIlJlcG9ydCIsCgkJCXNjb25mID0+ICRzY29uZiwKICAgICAgICAJ -KTsKCgkJbXkgJHNlYXJjaF9saW5rcyA9ICRyZXBvLT5tYWtlX2RvY19mcmFnbWVudDsKCQlteSAk -bmV3X2xpbmsgPSAkcmVwby0+cmVuZGVyX2xpbmsoICIkbmV3X2Jhc2V1cmwmX2FjdGlvbl9uZXdz -ZWFyY2g9MSIgKTsKCSAgIAkkbmV3X2xpbmstPmFwcGVuZENoaWxkKCAkcmVwby0+aHRtbF9waHJh -c2UoICJsaWIvc2VhcmNoZXhwcmVzc2lvbjpuZXciICkgKTsKCQkkc2VhcmNoX2xpbmtzLT5hcHBl -bmRDaGlsZCggJG5ld19saW5rICk7CgoJCSNhZGQgYSBzZXBhcmF0b3IuLi4KCQkkc2VhcmNoX2xp -bmtzLT5hcHBlbmRDaGlsZCggJHJlcG8tPmh0bWxfcGhyYXNlKCAiVXBkYXRlL1ZpZXdzOmdyb3Vw -X3NlcGFyYXRvciIgKSApOwoKCQkjc2V0IHVwIHJlZmluZSBzZWFyY2ggbGluawoJCW15ICRyZWZp -bmVfYmFzZXVybCA9IFVSSS0+bmV3KCAkc2VsZi0+e3Nlc3Npb259LT5nZXRfdXJpICk7CiAgICAg -ICAgCSRyZWZpbmVfYmFzZXVybC0+cXVlcnlfZm9ybSgKCSAgICAgICAgCWNhY2hlID0+ICRjYWNo -ZWlkLAoJICAgICAgICAgICAgICAgIGV4cCA9PiAkZXNjZXhwLAogICAgICAgIAkgICAgICAgIHNj -cmVlbiA9PiAiUmVwb3J0IiwKICAgICAgICAgICAgICAgIAlkYXRhc2V0ID0+ICRzZWxmLT57ZGF0 -YXNldGlkfSwKICAgICAgICAgICAgICAgIAlvcmRlciA9PiAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntz -ZWFyY2h9LT57Y3VzdG9tX29yZGVyfSwKCQkJc2NvbmYgPT4gJHNjb25mLAogICAgICAgIAkpOwoK -CQlteSAkcmVmaW5lX2xpbmsgPSAkcmVwby0+cmVuZGVyX2xpbmsoICIkcmVmaW5lX2Jhc2V1cmwm -X2FjdGlvbl91cGRhdGU9MSIgKTsKICAgICAgCQkkcmVmaW5lX2xpbmstPmFwcGVuZENoaWxkKCAk -cmVwby0+aHRtbF9waHJhc2UoICJsaWIvc2VhcmNoZXhwcmVzc2lvbjpyZWZpbmUiICkgKTsgICAJ -ICAgICAgICAgCgkgICAgICAgICRzZWFyY2hfbGlua3MtPmFwcGVuZENoaWxkKCAkcmVmaW5lX2xp -bmsgKTsKCgkJJGNodW5rLT5hcHBlbmRDaGlsZCggJHJlcG8tPmh0bWxfcGhyYXNlKCAiUmVwb3J0 -OnNlYXJjaF9saW5rcyIsIGxpbmtzPT4kc2VhcmNoX2xpbmtzICkgKTsKCX0KCglyZXR1cm4gJGNo -dW5rOwp9CgoKI2FkZHMgYSBuZXcgY2hlY2tib3ggdG8gYWxsb3cgdGhlIHVzZXIgdG8gY2hvb3Nl -IHdoaWNoIGZpZWxkcyB0byBleHBvcnQKc3ViIF9leHBvcnRfZmllbGRfY2hlY2tib3gKewoJbXko -ICRzZWxmLCAkcmVwbywgJGZpZWxkbmFtZSwgJHVsLCAkZmllbGRsYWJlbCApID0gQF87CgoJbXkg -JGxpID0gJHJlcG8tPm1ha2VfZWxlbWVudCggImxpIiApOwoJJHVsLT5hcHBlbmRDaGlsZCggJGxp -ICk7CgogICAgICAgIG15ICRjaGVja2JveCA9ICRyZXBvLT5tYWtlX2VsZW1lbnQoICJpbnB1dCIs -IHR5cGUgPT4gImNoZWNrYm94IiwgaWQgPT4gJGZpZWxkbmFtZSwgbmFtZSA9PiAkZmllbGRuYW1l -LCB2YWx1ZSA9PiAkZmllbGRuYW1lICk7CglpZiggZGVmaW5lZCAkcmVwby0+Y29uZmlnKCAkc2Vs -Zi0+e2V4cG9ydF9jb25mfSwgImV4cG9ydGZpZWxkX2RlZmF1bHRzIiApICkKCXsKCQlpZiggKCBn -cmVwIHsgJGZpZWxkbmFtZSBlcSAkXyB9IEB7JHJlcG8tPmNvbmZpZyggJHNlbGYtPntleHBvcnRf -Y29uZn0sICJleHBvcnRmaWVsZF9kZWZhdWx0cyIgKX0gKSB8fCAoIHNjYWxhciggQHskcmVwby0+ -Y29uZmlnKCAkc2VsZi0+e2V4cG9ydF9jb25mfSwgImV4cG9ydGZpZWxkX2RlZmF1bHRzIiApfSAp -ID09IDAgKSApCgkJewoJCQkjb25seSBjaGVjayBkZWZhdWx0cyBvciBjaGVjayBldmVyeXRoaW5n -IGlmIGRlZmF1bHRzIG5vdCBkZWZpbmVkCgkJCSRjaGVja2JveC0+c2V0QXR0cmlidXRlKCAiY2hl -Y2tlZCIsICJ5ZXMiICk7CgkJfQoJfQoJbXkgJGxhYmVsID0gJHJlcG8tPm1ha2VfZWxlbWVudCgg -ImxhYmVsIiwgZm9yID0+ICRmaWVsZG5hbWUgKTsKCSRsYWJlbC0+YXBwZW5kQ2hpbGQoICRmaWVs -ZGxhYmVsICk7CgoJJGxpLT5hcHBlbmRDaGlsZCggJGNoZWNrYm94ICk7CgkkbGktPmFwcGVuZENo -aWxkKCAkbGFiZWwgKTsKfQoKIyMjIHV0aWxpdHkgbWV0aG9kcwoKIyBUT0RPIHNob3VsZCB1c2Ug -IkpTT04iIHBhY2thZ2UKc3ViIHRvX2pzb24KewogICAgICAgIG15KCAkc2VsZiwgJG9iamVjdCAp -ID0gQF87CgoJcmV0dXJuICIiIGlmKCAhZGVmaW5lZCAkb2JqZWN0ICk7CgojIFVURi04IGlzc3Vl -czoKIwlyZXR1cm4gSlNPTi0+bmV3LT51dGY4KDEpLT5lbmNvZGUoICRvYmplY3QgKTsKCiAgICAg -ICAgaWYoIHJlZiggJG9iamVjdCApIGVxICdIQVNIJyApCiAgICAgICAgewogICAgICAgICAgICAg -ICAgbXkgQHN0dWZmOwogICAgICAgICAgICAgICAgd2hpbGUoIG15KCAkaywgJHYgKSA9IGVhY2go -ICUkb2JqZWN0ICkgKQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAgICBu -ZXh0IGlmKCAhRVByaW50czo6VXRpbHM6OmlzX3NldCggJHYgKSApOyAgICAgICAjIG9yICdudWxs -JyA/CiAgICAgICAgICAgICAgICAgICAgICAgIHB1c2ggQHN0dWZmLCBFUHJpbnRzOjpVdGlsczo6 -anNfc3RyaW5nKCAkayApLic6Jy4kc2VsZi0+dG9fanNvbiggJHYgKQogICAgICAgICAgICAgICAg -fQogICAgICAgICAgICAgICAgcmV0dXJuICd7JyAuIGpvaW4oICIsIiwgQHN0dWZmICkgLiAnfSc7 -CiAgICAgICAgfQogICAgICAgIGVsc2lmKCByZWYoICRvYmplY3QgKSBlcSAnQVJSQVknICkKICAg -ICAgICB7CiAgICAgICAgICAgICAgICBteSBAc3R1ZmY7CiAgICAgICAgICAgICAgICBmb3JlYWNo -KCBAJG9iamVjdCApCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAgIG5l -eHQgaWYoICFFUHJpbnRzOjpVdGlsczo6aXNfc2V0KCAkXyApICk7CiAgICAgICAgICAgICAgICAg -ICAgICAgIHB1c2ggQHN0dWZmLCAkc2VsZi0+dG9fanNvbiggJF8gKTsKICAgICAgICAgICAgICAg -IH0KICAgICAgICAgICAgICAgIHJldHVybiAnWycgLiBqb2luKCAiLCIsIEBzdHVmZiApIC4gJ10n -OwogICAgICAgIH0KCiAgICAgICAgcmV0dXJuIEVQcmludHM6OlV0aWxzOjpqc19zdHJpbmcoICRv -YmplY3QgKTsKfQoKc3ViIGV4cG9ydF9wbHVnaW5zCnsKICAgICAgICBteSggJHNlbGYsICRnZW5l -cmljICkgPSBAXzsKCglteSBAcGx1Z2luX2lkczsKCQoJbXkgJHJlcG8gPSAkc2VsZi0+cmVwb3Np -dG9yeTsKCglpZiggZGVmaW5lZCAkcmVwby0+Y29uZmlnKCAkc2VsZi0+e2V4cG9ydF9jb25mfSwg -ImV4cG9ydF9wbHVnaW5zIiApICkKCXsKCQlAcGx1Z2luX2lkcyA9IEB7JHJlcG8tPmNvbmZpZygg -JHNlbGYtPntleHBvcnRfY29uZn0sICJleHBvcnRfcGx1Z2lucyIgKX07Cgl9CQoJZWxzaWYoICRn -ZW5lcmljICkKCXsKIAkJQHBsdWdpbl9pZHMgPSAkcmVwby0+cGx1Z2luX2xpc3QoCiAgICAgICAg -ICAgICAgICAJdHlwZSA9PiAiRXhwb3J0IiwKCSAgICAgICAgICAgICAgICBjYW5fYWNjZXB0ID0+ -ICJyZXBvcnQvZ2VuZXJpYyIsCiAgICAgICAgCSAgICAgICAgaXNfdmlzaWJsZSA9PiAic3RhZmYi -LAoJCQlpc19hZHZlcnRpc2VkID0+IDEsCgkgICAgICAgICk7Cgl9CgllbHNlCgl7CiAgICAgICAg -CUBwbHVnaW5faWRzID0gJHJlcG8tPnBsdWdpbl9saXN0KAogICAgICAgICAgICAgICAgCXR5cGUg -PT4gIkV4cG9ydCIsCgkgICAgICAgICAgICAgICAgY2FuX2FjY2VwdCA9PiAicmVwb3J0LyIuJHNl -bGYtPmdldF9yZXBvcnQsCiAgICAgICAgCSAgICAgICAgaXNfdmlzaWJsZSA9PiAic3RhZmYiLAoJ -CQlpc19hZHZlcnRpc2VkID0+IDEsCgkgICAgICAgICk7CiAgICAgICAgfQoJbXkgQHBsdWdpbnM7 -Cglmb3JlYWNoIG15ICRpZCAoIEBwbHVnaW5faWRzICkKICAgICAgICB7CiAgICAgICAgICAgICAg -ICBteSAkcCA9ICRyZXBvLT5wbHVnaW4oICIkaWQiICkgb3IgbmV4dDsKICAgICAgICAgICAgICAg -IHB1c2ggQHBsdWdpbnMsICRwOwogICAgICAgIH0KCiAgICAgICAgcmV0dXJuIEBwbHVnaW5zOwp9 -CgpzdWIgcmVwb3J0X3BsdWdpbnMKewoJbXkoICRzZWxmICkgPSBAXzsKCgkjIHNmMiAtIGNhbid0 -IGxpc3QgdmlhIHR5cGUgPT4gIlNlYXJjaDo6UmVwb3J0IiA/IAogICAgICAgIG15IEBwbHVnaW5f -aWRzID0gJHNlbGYtPnJlcG9zaXRvcnktPnBsdWdpbl9saXN0KAogICAgICAgICAgICAgICAgdHlw -ZSA9PiAiU2NyZWVuIiwKICAgICAgICApOwoKICAgICAgICBteSBAcGx1Z2luczsKCWZvcmVhY2gg -bXkgJGlkICggQHBsdWdpbl9pZHMgKQogICAgICAgIHsKCQluZXh0IGlmKCAkaWQgIX4gL15TY3Jl -ZW46OlJlcG9ydDo6LyApOwkjIG5vdGUgdGhpcyBhbHNvIGZpbHRlcnMgb3V0ICRzZWxmIChha2Eg -U2NyZWVuOjpSZXBvcnQpCgogICAgICAgICAgICAgICAgbXkgJHAgPSAkc2VsZi0+cmVwb3NpdG9y -eS0+cGx1Z2luKCAiJGlkIiApOwoJCW5leHQgaWYoICFkZWZpbmVkICRwIHx8ICEkcC0+Y2FuX2Jl -X3ZpZXdlZCApOwoKICAgICAgICAgICAgICAgIHB1c2ggQHBsdWdpbnMsICRwOwogICAgICAgIH0K -CiAgICAgICAgcmV0dXJuIEBwbHVnaW5zOwp9CgojcmV0dXJucyBhIGhhc2ggb2YgdmFsdWVzIG1h -cHBlZCB0byBhIGxhYmVsIGFuZCBhIGxpc3QKI2lmIGlkc19vbmx5IGlzIHNldCB0aGUgbGlzdCBv -ZiBpdGVtcyBhcmUganVzdCByZXByZXNlbnRlZCBieSB0aGVpciBpZCAodXNlZCBieSByZXBvcnQg -SlMpCnN1YiBnZXRfZ3JvdXBlZF9pdGVtcwp7CglteSggJHNlbGYsICRpdGVtcywgJGlkc19vbmx5 -ICkgPSBAXzsKCW15ICRzZXNzaW9uID0gJHNlbGYtPntzZXNzaW9ufTsKCW15ICVncm91cGVkOwoK -CW15ICRncm91cGluZyA9ICRzZWxmLT57cHJvY2Vzc29yfS0+e2dyb3VwfTsKCglteSAkbWV0YWZp -ZWxkID0gJGl0ZW1zLT5nZXRfZGF0YXNldC0+ZmllbGQoICRncm91cGluZyApOwoKCSNzZXQgZ3Jv -dXBfb3B0cyBpZiBhcHByb3ByaWF0ZQoJaWYoIGRlZmluZWQgJHNlbGYtPntwcm9jZXNzb3J9LT57 -Z3JvdXBfb3B0c30gKQoJewoJCWlmKCAkbWV0YWZpZWxkLT50eXBlIGVxICJkYXRlIiApCgkJewoJ -CQkkbWV0YWZpZWxkLT57cmVuZGVyX3Jlc30gPSAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntncm91cF9v -cHRzfS0+e3Jlc30gaWYgZXhpc3RzICRzZWxmLT57cHJvY2Vzc29yfS0+e2dyb3VwX29wdHN9LT57 -cmVzfTsKCQl9Cgl9CgoJI2NyZWF0ZSBhIGhhc2ggb2YgZmllbGQgdmFsdWVzIHRvIGl0ZW1zIChv -ciBpdGVtIGlkcykKCSRpdGVtcy0+bWFwKCBzdWIgewoJICAgICAgIAlteSggJHNlc3Npb24sICRk -YXRhc2V0LCAkaXRlbSApID0gQF87CgkJCgkJbXkgJG11bHRpcGxlID0gJG1ldGFmaWVsZC0+Z2V0 -X3Byb3BlcnR5KCAibXVsdGlwbGUiICk7CgkJbXkgQGdyb3VwX3ZhbHVlczsKCQlpZiggJG11bHRp -cGxlICkKICAgICAgICAgICAgICAgIHsKCQkJQGdyb3VwX3ZhbHVlcyA9IEB7JGl0ZW0tPnZhbHVl -KCAkZ3JvdXBpbmcgKX07CgkJfQoJCWVsc2UKCQl7CQkJCgkJCUBncm91cF92YWx1ZXMgPSAoJGl0 -ZW0tPnZhbHVlKCAkZ3JvdXBpbmcgKSk7CgkJfQoJCgkJaWYoIHNjYWxhciBAZ3JvdXBfdmFsdWVz -ID4gMCApCgkJewoJCQlmb3JlYWNoIG15ICRncm91cF92YWx1ZSAoIEBncm91cF92YWx1ZXMgKQoJ -CQl7CgkJCQlteSAkZ3JvdXBfaWQgPSAkbWV0YWZpZWxkLT5nZXRfaWRfZnJvbV92YWx1ZSggJHNl -c3Npb24sICRncm91cF92YWx1ZSApOwoJCQkJI3RydW5jYXRlIGdyb3VwIGlmIGFwcHJvcHJpYXRl -CgkJCQlpZiggZGVmaW5lZCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntncm91cF9vcHRzfSApCgkJCQl7 -CgkJCQkJJGdyb3VwX2lkID0gIHN1YnN0ciggIlx1JGdyb3VwX2lkIiwgMCwgJHNlbGYtPntwcm9j -ZXNzb3J9LT57Z3JvdXBfb3B0c30tPnt0cnVuY2F0ZX0gKSBpZiBleGlzdHMgJHNlbGYtPntwcm9j -ZXNzb3J9LT57Z3JvdXBfb3B0c30tPnt0cnVuY2F0ZX07CgkJCQl9CgoJCSAgICAgICAgCWlmKCBl -eGlzdHMgJGdyb3VwZWR7JGdyb3VwX2lkfSApICN3ZSd2ZSBhbHJlYWR5IHNldCB0aGlzIGxpc3Qg -dXAsIHB1c2ggYSBuZXcgaXRlbSBvbiB0byB0aGUgbGlzdAoJCSAgICAgICAgICAgICAgIAl7CgkJ -CQkJaWYoICRpZHNfb25seSApICNzb21ldGltZXMgd2Ugb25seSB3YW50IGlkcyByYXRoZXIgdGhh -biB0aGUgd2hvbGUgaXRlbQoJCQkJCXsKCQkJCQkJcHVzaCBAeyRncm91cGVkeyRncm91cF9pZH19 -LCAkaXRlbS0+aWQ7CgkJCQkJfQoJCQkJCWVsc2UKCQkJCQl7CgkJCQkJCXB1c2ggQHskZ3JvdXBl -ZHskZ3JvdXBfaWR9fSwgJGl0ZW07CgkJCQkJfQoJICAgICAgIAkJICAgICAgICB9CiAgICAgICAg -CSAgICAgIAkJZWxzZSAjc2V0IHVwIGEgbGlzdCBmb3IgdGhpcyBncm91cAoJICAgICAgICAJICAg -ICAgIAl7CgkJCQkJbXkgQGdyb3VwZWRfaXRlbXM7CgkJCQkJaWYoICRpZHNfb25seSApICNzb21l -dGltZXMgd2Ugb25seSB3YW50IGlkcyByYXRoZXIgdGhhbiB0aGUgd2hvbGUgaXRlbQoJCSAgICAg -ICAgICAgICAgICAgICAgICAgIHsJCiAgICAgICAgCQkgICAgICAgICAgICAgICAgICAgICAgICBA -Z3JvdXBlZF9pdGVtcyA9ICgkaXRlbS0+aWQpOwogICAgICAgICAgICAgICAgCQkgICAgICAgIH0K -CSAgICAgICAgICAgICAgICAJICAgICAgICBlbHNlCiAgICAgICAgCSAgICAgICAgICAgICAgICAJ -ewoJICAgICAgICAgICAgICAgIAkgICAgICAgICAgICAgICAgQGdyb3VwZWRfaXRlbXMgPSAoJGl0 -ZW0pOwogICAgICAgIAkJICAgICAgICAgICAgICAgCX0KCSAgICAgICAgICAgICAgICAJICAgICAg -ICAkZ3JvdXBlZHskZ3JvdXBfaWR9ID0gW0Bncm91cGVkX2l0ZW1zXTsKCQkJCX0KICAgICAgICAg -ICAgICAgCQl9CgkJfQoJCWVsc2UKCQl7CgkJCW15ICRncm91cF9pZCA9ICJVbnNwZWNpZmllZCAi -IC4gJG1ldGFmaWVsZC0+bmFtZTsKICAJICAgIAkJaWYoIGV4aXN0cyAkZ3JvdXBlZHskZ3JvdXBf -aWR9ICkgI3dlJ3ZlIGFscmVhZHkgc2V0IHRoaXMgbGlzdCB1cCwgcHVzaCBhIG5ldyBpdGVtIG9u -IHRvIHRoZSBsaXN0CgkJICAJewoJCQkJaWYoICRpZHNfb25seSApICNzb21ldGltZXMgd2Ugb25s -eSB3YW50IGlkcyByYXRoZXIgdGhhbiB0aGUgd2hvbGUgaXRlbQoJCQkJewoJCQkJCXB1c2ggQHsk -Z3JvdXBlZHskZ3JvdXBfaWR9fSwgJGl0ZW0tPmlkOwoJCQkJfQoJCQkJZWxzZQoJCQkJewoJCQkJ -CXB1c2ggQHskZ3JvdXBlZHskZ3JvdXBfaWR9fSwgJGl0ZW07CgkJCQl9CgkgICAgICAgCQl9CiAg -ICAgICAgCSAgICAgIAllbHNlICNzZXQgdXAgYSBsaXN0IGZvciB0aGlzIGdyb3VwCgkgICAgICAg -IAl7CgkJCQlteSBAZ3JvdXBlZF9pdGVtczsKCQkJCWlmKCAkaWRzX29ubHkgKSAjc29tZXRpbWVz -IHdlIG9ubHkgd2FudCBpZHMgcmF0aGVyIHRoYW4gdGhlIHdob2xlIGl0ZW0KCQkgICAgICAgICAg -ICAgICAgewkKICAgICAgICAJCQkJQGdyb3VwZWRfaXRlbXMgPSAoJGl0ZW0tPmlkKTsKICAgICAg -ICAgICAgICAgIAkJfQoJICAgICAgICAgICAgICAgIAllbHNlCiAgICAgICAgCSAgICAgICAgICAg -ICAgICB7CgkgICAgICAgICAgICAgICAJICAgICAgICAgICAgICAgIEBncm91cGVkX2l0ZW1zID0g -KCRpdGVtKTsKICAgICAgICAJICAgICAgICAgICAgICAgCX0KCSAgICAgICAgICAgICAgCSAgICAg -ICAgJGdyb3VwZWR7JGdyb3VwX2lkfSA9IFtAZ3JvdXBlZF9pdGVtc107CgkJCX0KCQl9CiAgICAg -ICAJfSApOwoKCSNub3cgc29ydCB0aGUgZ3JvdXBzIGFuZCBhZGQgaHVtYW4gcmVhZGFibGUgbGFi -ZWxzCglteSBAc29ydGVkX2dyb3VwczsKCQoJbXkgJHJldmVyc2UgPSAwOwoJJHJldmVyc2UgPSAk -c2VsZi0+e3Byb2Nlc3Nvcn0tPntncm91cF9vcHRzfS0+e3JldmVyc2Vfb3JkZXJ9IGlmIGV4aXN0 -cyAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntncm91cF9vcHRzfS0+e3JldmVyc2Vfb3JkZXJ9OwoJaWYo -ICRtZXRhZmllbGQtPnR5cGUgZXEgIm5hbWVkc2V0IiApCgl7CgkJbXkoICR0YWdzLCAkbGFiZWxz -ICkgPSAkbWV0YWZpZWxkLT50YWdzX2FuZF9sYWJlbHMoICRzZXNzaW9uICk7CgkJI2NvbnZlcnQg -dGFncyB0byBhIGhhc2ggb2YgdmFsdWVzIGFuZCBhIHByaW9yaXR5IChmb3Igb3JkZXJpbmcpCgkJ -bXkgJXByaW9yaXR5OwoJCW15ICRpbmRleCA9IDE7CgkJZm9yZWFjaCBteSAkdGFnIChAeyR0YWdz -fSApCgkJewoJCQkkcHJpb3JpdHl7JHRhZ30gPSAkaW5kZXg7CgkJCSRpbmRleCsrOwoJCX0KCQlm -b3JlYWNoIG15ICRrZXkgKHNvcnQgeyRwcmlvcml0eXskYX0gPD0+ICRwcmlvcml0eXskYn19IGtl -eXMgJWdyb3VwZWQpCiAgICAgICAgCXsKCQkJcHVzaCBAc29ydGVkX2dyb3VwcywgJHNlbGYtPl9t -YWtlX2dyb3VwZWRfaXRlbSggJGdyb3VwZWR7JGtleX0sICRsYWJlbHMtPnska2V5fSApOwoJCX0K -CX0KCWVsc2lmKCAkbWV0YWZpZWxkLT50eXBlIGVxICJzdWJqZWN0IiApCgl7CQkKCQlteSAkZHMg -PSAkc2Vzc2lvbi0+ZGF0YXNldCggInN1YmplY3QiICk7CgkJbXkgQHZhbHVlcyA9IGtleXMgJWdy -b3VwZWQ7CgkJbXkgJHNvcnRlZCA9ICRtZXRhZmllbGQtPnNvcnRfdmFsdWVzKCAkc2Vzc2lvbiwg -XEB2YWx1ZXMgKTsKCQlteSAlcHJpb3JpdHk7CgkJbXkgJGluZGV4ID0gMTsKICAgICAgICAgICAg -ICAgIGZvcmVhY2ggbXkgJHZhbHVlIChAeyRzb3J0ZWR9ICkKICAgICAgICAgICAgICAgIHsKICAg -ICAgICAgICAgICAgICAgICAgICAgJHByaW9yaXR5eyR2YWx1ZX0gPSAkaW5kZXg7CiAgICAgICAg -ICAgICAgICAgICAgICAgICRpbmRleCsrOwogICAgICAgICAgICAgICAgfQoJCWZvcmVhY2ggbXkg -JGtleSAoc29ydCB7JHByaW9yaXR5eyRhfSA8PT4gJHByaW9yaXR5eyRifX0ga2V5cyAlZ3JvdXBl -ZCkKICAgICAgICAgICAgICAgIHsKCQkJbXkgJHN1YmogPSAkZHMtPmRhdGFvYmooICRrZXkgKTsK -ICAgICAgICAgICAgICAgICAgICAgICAgcHVzaCBAc29ydGVkX2dyb3VwcywgJHNlbGYtPl9tYWtl -X2dyb3VwZWRfaXRlbSggJGdyb3VwZWR7JGtleX0sIEVQcmludHM6OlV0aWxzOjp0cmVlX3RvX3V0 -ZjgoICRzdWJqLT5yZW5kZXJfZGVzY3JpcHRpb24gKSApIGlmIGRlZmluZWQgJHN1Ymo7CiAgICAg -ICAgICAgICAgICB9Cgl9CgllbHNpZiggJG1ldGFmaWVsZC0+dHlwZSBlcSAiZGF0ZSIgKQoJewoJ -CWlmKCAkcmV2ZXJzZSApCgkJewoJCQlmb3JlYWNoIG15ICRrZXkgKCBzb3J0IHskYiA8PT4gJGF9 -IGtleXMgJWdyb3VwZWQgKQoJCQl7CgkJCQlwdXNoIEBzb3J0ZWRfZ3JvdXBzLCAkc2VsZi0+X21h -a2VfZ3JvdXBlZF9pdGVtKCAkZ3JvdXBlZHska2V5fSwgJGtleSApOwoJCQl9CgkJfQoJCWVsc2UK -CQl7CgkJCWZvcmVhY2ggbXkgJGtleSAoIHNvcnQgeyRhIDw9PiAkYn0ga2V5cyAlZ3JvdXBlZCAp -CgkJCXsKCQkJCXB1c2ggQHNvcnRlZF9ncm91cHMsICRzZWxmLT5fbWFrZV9ncm91cGVkX2l0ZW0o -ICRncm91cGVkeyRrZXl9LCAka2V5ICk7CgkJCX0KCQl9Cgl9CgllbHNlCgl7CQoJCWlmKCAkcmV2 -ZXJzZSApCgkJewoJCQlmb3JlYWNoIG15ICRrZXkgKCBzb3J0IHskYiBjbXAgJGF9IGtleXMgJWdy +bjsKCiAgICAgICAgbXkgJHNlYXJjaGRhdGFzZXRpZCA9ICRyZXBvcnRfcGx1Z2luLT57c2VhcmNo +ZGF0YXNldGlkfTsKICAgICAgICBpZiggZGVmaW5lZCAkcmVwb3J0X3BsdWdpbi0+cGFyYW0oInNl +YXJjaGRhdGFzZXRpZCIpICkKICAgICAgICB7CiAgICAgICAgICAgICRzZWFyY2hkYXRhc2V0aWQg +PSAkcmVwb3J0X3BsdWdpbi0+cGFyYW0oInNlYXJjaGRhdGFzZXRpZCIpOwogICAgICAgIH0KCiAg +ICAgICAgbXkgJHJlcG9ydF9kcyA9ICRzZXNzaW9uLT5kYXRhc2V0KCAkc2VhcmNoZGF0YXNldGlk +ICk7CiAgICAgICAgaWYoIGRlZmluZWQgJHJlcG9ydF9kcyApCiAgICAgICAgewogICAgICAgICAg +ICAgICAgJHNlbGYtPntwcm9jZXNzb3J9LT57ZGF0YXNldGlkfSA9ICRyZXBvcnRfZHMtPmJhc2Vf +aWQ7CiAgICAgICAgICAgICAgICBteSAkc2NvbmYgPSAkcmVwb3J0X2RzLT5zZWFyY2hfY29uZmln +KCAkcmVwb3J0X3BsdWdpbi0+e3Njb25mfSApOwoJCiAgICAgICAgICAgICAgICBteSAkZm9ybWF0 +ID0gInJlcG9ydC8iIC4gJHJlcG9ydF9kcy0+YmFzZV9pZDsKICAgICAgICAgICAgICAgICRzZWxm +LT57cHJvY2Vzc29yfS0+e3NlYXJjaH0gPSAkc2Vzc2lvbi0+cGx1Z2luKCAiU2VhcmNoIiApLT5w +bHVnaW5zKAogICAgICAgICAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAga2VlcF9jYWNoZSA9PiAxLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +IHNlc3Npb24gPT4gJHNlbGYtPntzZXNzaW9ufSwKICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICBkYXRhc2V0ID0+ICRyZXBvcnRfZHMsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgJXskc2NvbmZ9CiAgICAgICAgICAgICAgICAgICAgICAgIH0sCiAgICAgICAgICAgICAgICAg +ICAgICAgIHR5cGUgPT4gIlNlYXJjaCIsCiAgICAgICAgICAgICAgICAgICAgICAgIGNhbl9zZWFy +Y2ggPT4gJGZvcm1hdCwKICAgICAgICAgICAgICAgICk7Cgl9Cn0KCnN1YiBhbGxvd19uZXdzZWFy +Y2ggeyByZXR1cm4gMTsgfQoKc3ViIGFsbG93X3VwZGF0ZSB7IHJldHVybiAxOyB9CgpzdWIgYWN0 +aW9uX25ld3NlYXJjaAp7CiAgICAgICAgbXkoICRzZWxmICkgPSBAXzsKCiAgICAgICAgbXkgJHNl +c3Npb24gPSAkc2VsZi0+e3Nlc3Npb259OwoKICAgICAgICAjJHNlbGYtPntwcm9jZXNzb3J9LT57 +cmVwb3J0fSA9ICRzZXNzaW9uLT5wYXJhbSggJ3JlcG9ydCcgKTsKICAgICAgICAjJHNlbGYtPntw +cm9jZXNzb3J9LT57c2NyZWVuaWR9ID0gJHNlbGYtPntwcm9jZXNzb3J9LT57cmVwb3J0fTsKICAg +ICAgICAjJHNlbGYtPntwcm9jZXNzb3J9LT57YWN0aW9ufSA9ICJuZXdzZWFyY2giOwogICAgICAg +ICMkc2VsZi0+X2NyZWF0ZV9zZWFyY2g7Cn0KCnN1YiBhY3Rpb25fdXBkYXRlCnsKICAgICAgICBt +eSggJHNlbGYgKSA9IEBfOwoKICAgICAgICBteSAkc2Vzc2lvbiA9ICRzZWxmLT57c2Vzc2lvbn07 +CgogICAgICAgICMkc2VsZi0+e3Byb2Nlc3Nvcn0tPntyZXBvcnR9ID0gJHNlc3Npb24tPnBhcmFt +KCAncmVwb3J0JyApOwogICAgICAgICMkc2VsZi0+e3Byb2Nlc3Nvcn0tPntzY3JlZW5pZH0gPSAk +c2VsZi0+e3Byb2Nlc3Nvcn0tPntyZXBvcnR9OwogICAgICAgICMkc2VsZi0+e3Byb2Nlc3Nvcn0t +PnthY3Rpb259ID0gIm5ld3NlYXJjaCI7CiAgICAgICAgIyRzZWxmLT5fY3JlYXRlX3NlYXJjaDsK +fQoKc3ViIGFjdGlvbl9zZWFyY2gKewoJbXkoICRzZWxmICkgPSBAXzsKCgkkc2VsZi0+e3Byb2Nl +c3Nvcn0tPnthY3Rpb259ID0gInNlYXJjaCI7CgoJI3JlYWQgcGFyYW1ldGVycwoJbXkgJHNlc3Np +b24gPSAkc2VsZi0+e3Nlc3Npb259OwoKCSRzZWxmLT57cHJvY2Vzc29yfS0+e3JlcG9ydH0gPSAk +c2Vzc2lvbi0+cGFyYW0oICdyZXBvcnQnICk7CgoJJHNlbGYtPntwcm9jZXNzb3J9LT57c2NyZWVu +aWR9ID0gJHNlbGYtPntwcm9jZXNzb3J9LT57cmVwb3J0fTsKCSRzZWxmLT5fY3JlYXRlX3NlYXJj +aDsKCglteSAkbG9hZGVkID0gMDsKICAgICAgICBteSAkaWQgPSAkc2Vzc2lvbi0+cGFyYW0oICJj +YWNoZSIgKTsKICAgICAgICBpZiggZGVmaW5lZCAkaWQgKQogICAgICAgIHsKCQkkbG9hZGVkID0g +JHNlbGYtPntwcm9jZXNzb3J9LT57c2VhcmNofS0+ZnJvbV9jYWNoZSggJGlkICk7CiAgICAgICAg +fQoKICAgICAgICBpZiggISRsb2FkZWQgKQogICAgICAgIHsKICAgICAgICAgICAgICAgIG15ICRl +eHAgPSAkc2Vzc2lvbi0+cGFyYW0oICJleHAiICk7CiAgICAgICAgICAgICAgICBpZiggZGVmaW5l +ZCAkZXhwICkKICAgICAgICAgICAgICAgIHsKCQkJJHNlbGYtPntwcm9jZXNzb3J9LT57c2VhcmNo +fS0+ZnJvbV9zdHJpbmcoICRleHAgKTsKICAgICAgICAgICAgICAgICAgICAgICAgIyBjYWNoZSBl +eHBpcmVkLi4uCiAgICAgICAgICAgICAgICAgICAgICAgICRsb2FkZWQgPSAxOwogICAgICAgICAg +ICAgICAgfQogICAgICAgIH0KCiAgICAgICAgbXkgQHByb2JsZW1zOwogICAgICAgIGlmKCAhJGxv +YWRlZCApCiAgICAgICAgewoJCWZvciggJHNlbGYtPntwcm9jZXNzb3J9LT57c2VhcmNofS0+ZnJv +bV9mb3JtICkKICAgICAgICAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICRzZWxmLT57cHJvY2Vzc29yfS0+YWRkX21lc3NhZ2UoICJ3YXJuaW5nIiwgJF8g +KTsKICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgIH0KICAgICAgICAgIAoKCSNkaXNw +bGF5IHRoZSByZXN1bHRzCgkkc2VsZi0+cmVuZGVyOwp9CgpzdWIgcHJvcGVydGllc19mcm9tCnsK +CW15KCAkc2VsZiApID0gQF87CgoJbXkgJHJlcG8gPSAkc2VsZi0+cmVwb3NpdG9yeTsKCSRzZWxm +LT5TVVBFUjo6cHJvcGVydGllc19mcm9tOwoKCWlmKCBkZWZpbmVkICggbXkgJGRzaWQgPSAkc2Vs +Zi0+cGFyYW0oICJkYXRhc2V0aWQiICkgKSApCgl7CgkJJHNlbGYtPntwcm9jZXNzb3J9LT57ZGF0 +YXNldH0gPSAkc2VsZi0+cmVwb3NpdG9yeS0+ZGF0YXNldCggJGRzaWQgKTsKCX0KCgkjIHNmMiAt +IFRPRE8gLSBiYXJrIGlmIGRhdGFzZXQgaXMgbm90IHNldD8gcGVyaGFwcyB0aGVyZSBhcmUgb3Ro +ZXIgd2F5cyB0byBnZXQgdGhlIG9iamVjdHMgZnJvbS4uLgoJbXkgJHJlcG9ydCA9ICRzZWxmLT5n +ZXRfcmVwb3J0KCk7CgoJI2dldCBhIHNlYXJjaCBvYmplY3QgaWYgd2UgaGF2ZSBvbmUgZnJvbSBh +IHByZXZpb3VzIHNlYXJjaCBhY3Rpb24sIHNvIHRoYXQgd2UgbWlnaHQgbGF0ZXIgdXNlIGl0IHRv +IGRvIGFuIGV4cG9ydCBvciBzZWFyY2ggYWN0aW9uCgkkc2VsZi0+X2NyZWF0ZV9zZWFyY2g7CQoJ +aWYoIGRlZmluZWQgJHNlbGYtPnJlcG9zaXRvcnktPnBhcmFtKCAic2VhcmNoIiApICkKCXsKCQkk +c2VsZi0+e3Byb2Nlc3Nvcn0tPntzZWFyY2h9LT5mcm9tX3N0cmluZyggJHNlbGYtPnJlcG9zaXRv +cnktPnBhcmFtKCAic2VhcmNoIiApICkgaWYgZGVmaW5lZCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntz +ZWFyY2h9OwoJCSRzZWxmLT57cHJvY2Vzc29yfS0+e2V4cG9ydF9zZWFyY2h9ID0gMTsKCX0KCQoJ +bXkgJGZvcm1hdCA9ICRzZWxmLT5yZXBvc2l0b3J5LT5wYXJhbSggImV4cG9ydCIgKTsKCWlmKCAk +Zm9ybWF0ICYmICRyZXBvcnQgKQoJewoJCW15ICRwbHVnaW4gPSAkc2VsZi0+cmVwb3NpdG9yeS0+ +cGx1Z2luKCAiRXhwb3J0OjokZm9ybWF0IiwgcmVwb3J0ID0+ICRyZXBvcnQgKTsKCQlpZiggZGVm +aW5lZCAkcGx1Z2luICYmICggJHBsdWdpbi0+Y2FuX2FjY2VwdCggInJlcG9ydC8kcmVwb3J0IiAp +IHx8ICgkcGx1Z2luLT5jYW5fYWNjZXB0KCAicmVwb3J0L2dlbmVyaWMiICkgKSApICkKCQl7CgkJ +CSRzZWxmLT57cHJvY2Vzc29yfS0+e3BsdWdpbn0gPSAkcGx1Z2luOwoJCX0KCX0KCgkjbGlzdCBv +ZiBleHBvcnQgZmllbGRzIHJldHJpZXZlZCBmcm9tIG5vbi1hYnN0cmFjdCBpbnN0YW5jZXMgb2Yg +cmVwb3J0cwoJbXkgQGV4cG9ydGZpZWxkczsKCWlmKCBkZWZpbmVkICRyZXBvLT5jb25maWcoICRz +ZWxmLT57ZXhwb3J0X2NvbmZ9LCAiZXhwb3J0ZmllbGRzIiApICkKCXsKCQlteSBAa2V5czsKCQlp +ZiggZGVmaW5lZCAkcmVwby0+Y29uZmlnKCAkc2VsZi0+e2V4cG9ydF9jb25mfSwgImV4cG9ydGZp +ZWxkX29yZGVyIiApICkKCQl7CgkJCUBrZXlzID0gQHskcmVwby0+Y29uZmlnKCAkc2VsZi0+e2V4 +cG9ydF9jb25mfSwgImV4cG9ydGZpZWxkX29yZGVyIiApfTsKCQl9CgkJZWxzZQoJCXsKCQkJQGtl +eXMgPSBrZXlzICV7JHJlcG8tPmNvbmZpZyggJHNlbGYtPntleHBvcnRfY29uZn0sICJleHBvcnRm +aWVsZHMiICl9OyAKCQl9CgkJZm9yZWFjaCBteSAka2V5ICggQGtleXMgKQoJCXsKCQkJZm9yZWFj +aCBteSAkZmllbGRuYW1lICggQHskcmVwby0+Y29uZmlnKCAkc2VsZi0+e2V4cG9ydF9jb25mfSwg +ImV4cG9ydGZpZWxkcyIgKS0+eyRrZXl9fSApCgkJCXsKCQkJCXB1c2ggQGV4cG9ydGZpZWxkcywg +JGZpZWxkbmFtZSBpZiBkZWZpbmVkICRzZWxmLT5yZXBvc2l0b3J5LT5wYXJhbSggJGZpZWxkbmFt +ZSApOyAKCQkJfQoJCX0KCX0KCglteSAkc29ydCA9ICRzZWxmLT5yZXBvc2l0b3J5LT5wYXJhbSgg +InNvcnQiICk7CglpZiggZGVmaW5lZCAkc29ydCApCgl7CgkJJHNlbGYtPntwcm9jZXNzb3J9LT57 +c29ydH0gPSAkc29ydDsKCX0KCglteSAkZ3JvdXAgPSAkc2VsZi0+cmVwb3NpdG9yeS0+cGFyYW0o +ICJncm91cCIgKTsKCSRzZWxmLT57cHJvY2Vzc29yfS0+e2dyb3VwX2V4cH0gPSAkZ3JvdXA7ICNz +dG9yZSB0aGUgZ3JvdXAgZXhwcmVzc2lvbiBmb3IgbGF0ZXIgdXNlCgkKCSNkZWNvZGUgdGhlIGdy +b3VwIGV4cHJlc3Npb24KCW15ICVncm91cF9vcHRzOwoJaWYoIGRlZmluZWQgJGdyb3VwICkKCXsK +CQkjZ2V0IGZpZWxkIGFuZCBhc3NvY2lhdGVkIGNvbmZpZ3VyYXRpb24gYWJvdXQgdGhlIGdyb3Vw +LCBlLmcuIHJlcywgdHJ1bmNhdGUsIHJldmVyc2Vfb3JkZXIgZXRjLgoJCW15IEBncm91cCA9IHNw +bGl0KC87LywgJGdyb3VwICk7CgkJbXkgJGZpcnN0ID0gMTsKCQlmb3JlYWNoIG15ICRnIChAZ3Jv +dXApCgkJewoJCQlpZiggJGZpcnN0ICkKCQkJewoJCQkJJGdyb3VwID0gJGc7CgkJCX0KCQkJZWxz +ZQoJCQl7CgkJCQlteSBAb3B0cyA9IHNwbGl0KC89LywgJGcgKTsKCQkJCSRncm91cF9vcHRzeyRv +cHRzWzBdfSA9ICRvcHRzWzFdOwkJCgkJCX0KCQkJJGZpcnN0ID0gMDsKCQl9CgkJJHNlbGYtPntw +cm9jZXNzb3J9LT57Z3JvdXB9ID0gJGdyb3VwOwoJCSRzZWxmLT57cHJvY2Vzc29yfS0+e2dyb3Vw +X29wdHN9ID0gXCVncm91cF9vcHRzOwoJfQoKCSRzZWxmLT57cHJvY2Vzc29yfS0+e2V4cG9ydGZp +ZWxkc30gPSBcQGV4cG9ydGZpZWxkczsKfQoJCQojIFxAKHttZXRhX2ZpZWxkcz0+WyAiZmllbGQx +IiwgImZpZWxkMiIgImRvY3VtZW50LmZpZWxkMyIgXSwgbWVyZ2U9PiJBTlkiLCBtYXRjaD0+IkVY +IiwgdmFsdWU9PiJiZWVzIn0sIHttZXRhX2ZpZWxkcz0+WyAiZmllbGQ0IiBdLCB2YWx1ZT0+Imhv +bmV5In0pOwojIGUuZy4KIyByZXR1cm4gWyB7IG1ldGFfZmllbGRzID0+IFsgJ3R5cGUnIF0sIHZh +bHVlID0+ICdhcnRpY2xlJyB9IF0Kc3ViIGZpbHRlcnMKewoJcmV0dXJuIFtdOwp9CgojIGhvdyB0 +byBzZWxlY3QgaXRlbXMgaS5lLiB0aGUgc2xpY2Ugb2YgZGF0YSB3ZSB3YW50IHRvIHZhbGlkYXRl +L2V4cG9ydD8KIyAKc3ViIGl0ZW1zCnsKCW15KCAkc2VsZiApID0gQF87CglpZiggJHNlbGYtPntw +cm9jZXNzb3J9LT57YWN0aW9ufSBlcSAic2VhcmNoIiB8fCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntl +eHBvcnRfc2VhcmNofSApCiAgICAgICAJewoJCW15ICRyZXBvcnQgPSAkc2VsZi0+e3Byb2Nlc3Nv +cn0tPntyZXBvcnRfcGx1Z2lufTsJCgkJJHJlcG9ydC0+YXBwbHlfZmlsdGVycyBpZiAkcmVwb3J0 +LT5jYW4oICdhcHBseV9maWx0ZXJzJyApOwoKCQlteSAkaXRlbXMgPSAkc2VsZi0+e3Byb2Nlc3Nv +cn0tPntzZWFyY2h9LT5wZXJmb3JtX3NlYXJjaDsKCgkJaWYoIGRlZmluZWQgJHNlbGYtPntwcm9j +ZXNzb3J9LT57c29ydH0gKQoJCXsJCgkJCSRpdGVtcyA9ICRpdGVtcy0+cmVvcmRlciggJHNlbGYt +Pntwcm9jZXNzb3J9LT57c29ydH0gKTsKCQl9CgkJcmV0dXJuICRpdGVtczsKCX0KCWVsc2lmKCBk +ZWZpbmVkICRzZWxmLT57cHJvY2Vzc29yfS0+e2RhdGFzZXR9ICkgCgl7CgkJbXkgJXNlYXJjaF9v +cHRzID0gKCBmaWx0ZXJzID0+ICRzZWxmLT5maWx0ZXJzLCBzYXRpc2Z5X2FsbCA9PiAxICk7CgkJ +aWYoIGRlZmluZWQgJHNlbGYtPnBhcmFtKCAnY3VzdG9tX29yZGVyJyApICkKCQl7CgkJCSRzZWFy +Y2hfb3B0c3tjdXN0b21fb3JkZXJ9ID0gJHNlbGYtPnBhcmFtKCAnY3VzdG9tX29yZGVyJyApOwoJ +CX0KCgkJaWYoIGRlZmluZWQgJHNlbGYtPntwcm9jZXNzb3J9LT57c29ydH0gKSAjYW4gb3JkZXJp +bmcgc3BlY2lmaWVkIGJ5IHRoZSB1c2VyIHNob3VsZCB0cnVtcCB0aGUgcmVwb3J0cyBjdXN0b20g +b3JkZXIKCQl7CgkJCSRzZWFyY2hfb3B0c3tjdXN0b21fb3JkZXJ9ID0gJHNlbGYtPntwcm9jZXNz +b3J9LT57c29ydH07CgkJfQkKCQlyZXR1cm4gJHNlbGYtPntwcm9jZXNzb3J9LT57ZGF0YXNldH0t +PnNlYXJjaCggJXNlYXJjaF9vcHRzICk7Cgl9CgkjIHdlIGNhbid0IHJldHVybiBhbiBFUHJpbnRz +OjpMaXN0IGlmIHtkYXRhc2V0fSBpcyBub3QgZGVmaW5lZAoJcmV0dXJuIHVuZGVmOwp9CgojIGZy +b20gUmVwb3J0cy9ST1MvSm91cm5hbHMucG0KIyBUT0RPIE5vdGUgcXVpdGUgYSBsb3Qgb2YgcmVw +bGljYXRpb24gYmV0d2VlbiB0aGlzIGFuZCBFeHBvcnQ6OlJlcG9ydDo6Q1NWOjpvdXRwdXRfZGF0 +YW9iagpzdWIgdmFsaWRhdGVfZGF0YW9iagp7CglteSggJHBsdWdpbiwgJGRhdGFvYmogKSA9IEBf +OwoKCW15ICRyZXBvID0gJHBsdWdpbi0+cmVwb3NpdG9yeTsKCglteSAkcmVwb3J0X2ZpZWxkcyA9 +ICRwbHVnaW4tPnJlcG9ydF9maWVsZHMoICRkYXRhb2JqICk7CglteSAkdmFsX2ZpZWxkcyA9ICRw +bHVnaW4tPnZhbGlkYXRlX2ZpZWxkcyggJGRhdGFvYmogKTsKCgkjIHJlbGF0ZWQgb2JqZWN0cyBh +bmQgdGhlaXIgZGF0YXNldHMKCW15ICRvYmplY3RzID0gJHBsdWdpbi0+Z2V0X3JlbGF0ZWRfb2Jq +ZWN0cyggJGRhdGFvYmogKTsKCW15ICR2YWxpZF9kcyA9IHt9OwoJZm9yZWFjaCBteSAkZHNpZCAo +IGtleXMgJSRvYmplY3RzICkKCXsKCQkkdmFsaWRfZHMtPnskZHNpZH0gPSAkcmVwby0+ZGF0YXNl +dCggJGRzaWQgKTsKCX0KCglteSBAcHJvYmxlbXM7CgoJZm9yZWFjaCBteSAkZmllbGQgKCBAeyAk +cGx1Z2luLT5yZXBvcnRfZmllbGRzX29yZGVyKCAkZGF0YW9iaiApIHx8IFtdIH0gKQoJewoJCSMg +dmFsaWRhdGlvbiBhY3Rpb24KCQlteSAkdl9maWVsZCA9ICR2YWxfZmllbGRzLT57JGZpZWxkfTsK +CQluZXh0IHVubGVzcyBkZWZpbmVkICR2X2ZpZWxkOyAjIG5vIHZhbGlkYXRpb24gcmVxdWlyZWQK +CgkJIyBzaW1wbGUgY2FzZSAtIGNvZGUgaGFuZGxlcyB2YWxpZGF0aW9uCgkJaWYoIHJlZiggJHZf +ZmllbGQgKSBlcSAnQ09ERScgKQoJCXsKCQkJIyBhIHN1Ynt9IHdlIG5lZWQgdG8gcnVuCgkJCWV2 +YWwgewoJCQkJJiR2X2ZpZWxkKCAkcGx1Z2luLCAkb2JqZWN0cywgXEBwcm9ibGVtcyApOwoJCQl9 +OwoJCQlpZiggJEAgKQoJCQl7CgkJCQkkcmVwby0+bG9nKCAiVmFsaWRhdGlvbiBSdW50aW1lIGVy +cm9yOiAkQCIgKTsKCQkJfQoJCQluZXh0OwoJCX0KCQllbHNpZiggbGMgJHZfZmllbGQgbmUgInJl +cXVpcmVkIiApCgkJewoJCQkkcmVwby0+bG9nKCAiVmFsaWRhdGlvbiBSdW50aW1lIGVycm9yOiAk +dl9maWVsZCBtdXN0IGJlIGNvZGUgcmVmIG9yICdyZXF1aXJlZCciICk7CgkJCW5leHQ7CgkJfQoK +CQkjIGNoZWNrIHJlcXVpcmVkIHZhbHVlcwoKCQlteSAkdmFsdWU7ICMgdGhlIHZhbHVlIHRvIHZh +bGlkYXRlCgkJbXkgJGVwX2ZpZWxkID0gJHJlcG9ydF9maWVsZHMtPnskZmllbGR9OwoJCWlmKCBy +ZWYoICRlcF9maWVsZCApIGVxICdDT0RFJyApCgkJewoJCQkjIGEgc3Vie30gd2UgbmVlZCB0byBy +dW4KCQkJZXZhbCB7CgkJCQkkdmFsdWUgPSAmJGVwX2ZpZWxkKCAkcGx1Z2luLCAkb2JqZWN0cyAp +OwoJCQl9OwoJCQlpZiggJEAgKQoJCQl7CgkJCQkkcmVwby0+bG9nKCAiVmFsaWRhdGlvbiBSdW50 +aW1lIGVycm9yOiAkQCIgKTsKCQkJfQoJCX0KCQllbHNpZiggJGVwX2ZpZWxkID1+IC9eKFthLXpf +XSspXC4oWzAtOWEtel9dKykkLyApCgkJewoJCQkjIGEgc3RyYWlnaHQgbWFwcGluZyB3aXRoIGFu +IEVQcmludHMgZmllbGQKCQkJbXkoICRkc19pZCwgJGVwX2ZpZWxkbmFtZSApID0gKCAkMSwgJDIg +KTsKCQkJbXkgJGRzID0gJHZhbGlkX2RzLT57JGRzX2lkfTsKCgkJCWlmKCBkZWZpbmVkICRkcyAm +JiAkZHMtPmhhc19maWVsZCggJGVwX2ZpZWxkbmFtZSApICkKCQkJewoJCQkJJHZhbHVlID0gJG9i +amVjdHMtPnskZHNfaWR9LT52YWx1ZSggJGVwX2ZpZWxkbmFtZSApOwoJCQl9CgkJCWVsc2UKCQkJ +ewoJCQkJIyBkYXRhc2V0IG9yIGZpZWxkIGRvZXNuJ3QgZXhpc3QKCQkJCSRyZXBvLT5sb2coICJW +YWxpZGF0aW9uIFJ1bnRpbWUgZXJyb3I6IGRhdGFzZXQgJGRzX2lkIG9yIGZpZWxkICRlcF9maWVs +ZG5hbWUgZG9lc24ndCBleGlzdCIgKTsKCQkJfQoJCX0KCgkJIyBpcyBmaWVsZCBzZXQ/CgkJaWYo +ICFFUHJpbnRzOjpVdGlsczo6aXNfc2V0KCAkdmFsdWUgKSApCgkJewoJCQlwdXNoIEBwcm9ibGVt +cywgIk1pc3NpbmcgcmVxdWlyZWQgZmllbGQgJGZpZWxkIjsKCQl9Cgl9CgoJcmV0dXJuIEBwcm9i +bGVtczsKfQoKIyBUT0RPIE5vdGUgY29weSBvZiBFeHBvcnQ6OlJlcG9ydDo6Z2V0X3JlbGF0ZWRf +b2JqZWN0cwpzdWIgZ2V0X3JlbGF0ZWRfb2JqZWN0cwp7CglteSggJHBsdWdpbiwgJGRhdGFvYmog +KSA9IEBfOwoKCW15ICRjbWQgPSBbICdyZXBvcnRzJywgJHBsdWdpbi0+Z2V0X3JlcG9ydCwgJ2dl +dF9yZWxhdGVkX29iamVjdHMnIF07CiAgICAgICAgaWYoICRwbHVnaW4tPnJlcG9zaXRvcnktPmNh +bl9jYWxsKCBAJGNtZCApICkKICAgICAgICB7CgkJcmV0dXJuICRwbHVnaW4tPnJlcG9zaXRvcnkt +PmNhbGwoICRjbWQsICRwbHVnaW4tPnJlcG9zaXRvcnksICRkYXRhb2JqICkgfHwge307CiAgICAg +ICAgfQoKCSMganVzdCBwYXNzIHRoZSBkYXRhb2JqIGl0c2VsZgoJcmV0dXJuIHsKCQkkZGF0YW9i +ai0+ZGF0YXNldC0+Y29uZmlkID0+ICRkYXRhb2JqLAoJfTsKfQoKIyBUT0RPIE5vdGUgY29weSBv +ZiBFeHBvcnQ6OlJlcG9ydDo6cmVwb3J0X2ZpZWxkc19vcmRlcgpzdWIgcmVwb3J0X2ZpZWxkc19v +cmRlcgp7CglteSggJHBsdWdpbiApID0gQF87CgoJcmV0dXJuICRwbHVnaW4tPntyZXBvcnRfZmll +bGRzX29yZGVyfSBpZiggZGVmaW5lZCAkcGx1Z2luLT57cmVwb3J0X2ZpZWxkc19vcmRlcn0gKTsK +CglteSAkcmVwb3J0ID0gJHBsdWdpbi0+Z2V0X3JlcG9ydCgpOwoJcmV0dXJuIFtdIHVubGVzcygg +ZGVmaW5lZCAkcmVwb3J0ICk7CgoJJHBsdWdpbi0+e3JlcG9ydF9maWVsZHNfb3JkZXJ9ID0gJHBs +dWdpbi0+cmVwb3NpdG9yeS0+Y29uZmlnKCAncmVwb3J0cycsICRyZXBvcnQsICdmaWVsZHMnICk7 +CgoJcmV0dXJuICRwbHVnaW4tPntyZXBvcnRfZmllbGRzX29yZGVyfTsKfQoKIyBUT0RPIE5vdGUg +Y29weSBvZiBFeHBvcnQ6OlJlcG9ydDo6cmVwb3J0X2ZpZWxkcwpzdWIgcmVwb3J0X2ZpZWxkcwp7 +CglteSggJHBsdWdpbiApID0gQF87CgoJcmV0dXJuICRwbHVnaW4tPntyZXBvcnRfZmllbGRzfSBp +ZiggZGVmaW5lZCAkcGx1Z2luLT57cmVwb3J0X2ZpZWxkc30gKTsKCglteSAkcmVwb3J0ID0gJHBs +dWdpbi0+Z2V0X3JlcG9ydCgpOwoJcmV0dXJuIFtdIHVubGVzcyggZGVmaW5lZCAkcmVwb3J0ICk7 +CgoJJHBsdWdpbi0+e3JlcG9ydF9maWVsZHN9ID0gJHBsdWdpbi0+cmVwb3NpdG9yeS0+Y29uZmln +KCAncmVwb3J0cycsICRyZXBvcnQsICdtYXBwaW5ncycgKTsKCglyZXR1cm4gJHBsdWdpbi0+e3Jl +cG9ydF9maWVsZHN9Owp9CgpzdWIgdmFsaWRhdGVfZmllbGRzCnsKCW15KCAkcGx1Z2luICkgPSBA +XzsKCglyZXR1cm4gJHBsdWdpbi0+e3ZhbGlkYXRlX2ZpZWxkc30gaWYoIGRlZmluZWQgJHBsdWdp +bi0+e3ZhbGlkYXRlX2ZpZWxkc30gKTsKCglteSAkcmVwb3J0ID0gJHBsdWdpbi0+Z2V0X3JlcG9y +dCgpOwoJcmV0dXJuIFtdIHVubGVzcyggZGVmaW5lZCAkcmVwb3J0ICk7CgoJJHBsdWdpbi0+e3Zh +bGlkYXRlX2ZpZWxkc30gPSAkcGx1Z2luLT5yZXBvc2l0b3J5LT5jb25maWcoICdyZXBvcnRzJywg +JHJlcG9ydCwgJ3ZhbGlkYXRlJyApOwoKCXJldHVybiAkcGx1Z2luLT57dmFsaWRhdGVfZmllbGRz +fTsKfQoKIyMgcmVuZGVyaW5nCgojIFRoZSAic3BsYXNoIHBhZ2UiCnN1YiByZW5kZXJfc3BsYXNo +X3BhZ2UKewoJbXkoICRzZWxmICkgPSBAXzsKCglteSAkcmVwbyA9ICRzZWxmLT5yZXBvc2l0b3J5 +OwoJbXkgQHBsdWdpbnMgPSAkc2VsZi0+cmVwb3J0X3BsdWdpbnM7CgoJaWYoICFzY2FsYXIoIEBw +bHVnaW5zICkgKQoJewoJCXJldHVybiAkc2VsZi0+aHRtbF9waHJhc2UoICJub19yZXBvcnRzIiAp +OwoJfQoKCW15IEBsYWJlbHM7CglteSBAcGFuZWxzOwoKCSNwcmVzZXQgcmVwb3J0cwoJcHVzaCBA +bGFiZWxzLCAkcmVwby0+aHRtbF9waHJhc2UoICJyZXBvcnRzX3ByZXNldCIgKTsKCW15ICRwcmVz +ZXQgPSAkcmVwby0+bWFrZV9lbGVtZW50KCAiZGl2IiApOwoJbXkgJHByZXNldHNfYWRkZWQgPSAw +OwoKCSMgdG9wIGNhdGVnb3J5OiBieSBjbGFzc25hbWUgPiBSZXBvcnQ6OlJPUzo6U29tZVJlcG9y +dDEsIFJlcG9ydDo6Uk9TOjpTb21lUmVwb3J0MgoKCW15ICR1bCA9ICRzZWxmLT5yZXBvc2l0b3J5 +LT5tYWtlX2VsZW1lbnQoICd1bCcsIGNsYXNzID0+ICdlcF9yZXBvcnRfY2F0ZWdvcnknICk7CgoJ +IyBjYXQgfiBjYXRlZ29yeSAtICFtZWVvdwoJbXkgJGNhdCA9ICIiOwoJbXkgJGNhdF9saSA9IHVu +ZGVmOyAKCW15ICRjYXRfdWwgPSB1bmRlZjsKCQoJI3ByZXBhcmUgaGFzaCBvZiByZXBvcnRpbmcg +cGx1Z2lucwoJbXkgJXJlcG9ydF9oYXNoOwoJZm9yZWFjaCBteSAkcmVwb3J0X3BsdWdpbiAoIHNv +cnQgeyAkYS0+Z2V0X3N1YnR5cGUgY21wICRiLT5nZXRfc3VidHlwZSB9IEBwbHVnaW5zICkKCXsK +CQlteSAkcGx1Z2luX2NhdCA9ICRyZXBvcnRfcGx1Z2luLT5nZXRfc3VidHlwZTsKCQkkcGx1Z2lu +X2NhdCA9fiBzL15SZXBvcnQ6OihbXjpdKyk6Pzo/KC4qKSQvJDEvZzsJCgoJCWlmKCAkY2F0IG5l +ICRwbHVnaW5fY2F0ICkgI3dlIGhhdmUgYSB0b3AtY2F0ZWdvcnkKCQl7CgkJCSRjYXQgPSAkcGx1 +Z2luX2NhdDsKCQkJJHJlcG9ydF9oYXNoeyRjYXR9ID0gW107CgkJfQoKCQlpZiggRVByaW50czo6 +VXRpbHM6OmlzX3NldCggJDIgKSApCgkJewoJCQlwdXNoIEB7JHJlcG9ydF9oYXNoeyRjYXR9fSwg +JHJlcG9ydF9wbHVnaW47CgkJfQoJfQoJCglmb3IgbXkgJHRvcF9jYXQoIHNvcnQga2V5cyAlcmVw +b3J0X2hhc2ggKQoJewoJCW15IEByZXBvcnRfcGx1Z2lucyA9IEB7JHJlcG9ydF9oYXNoeyR0b3Bf +Y2F0fX07CgkJaWYoIHNjYWxhciggQHJlcG9ydF9wbHVnaW5zICkgPiAwICkKCQl7CgkJCSNyZW5k +ZXIgdG9wLWNhdGVnb3J5CgkJCSRjYXRfbGkgPSAkdWwtPmFwcGVuZENoaWxkKCAkc2VsZi0+cmVw +b3NpdG9yeS0+bWFrZV9lbGVtZW50KCAnbGknICkgKTsKCQkJJGNhdF9saS0+YXBwZW5kQ2hpbGQo +ICRzZWxmLT5yZXBvc2l0b3J5LT5odG1sX3BocmFzZSggIlBsdWdpbi9TY3JlZW4vUmVwb3J0LyR0 +b3BfY2F0OnRpdGxlIiApICk7CgoJCQkkY2F0X3VsID0gJGNhdF9saS0+YXBwZW5kQ2hpbGQoICRz +ZWxmLT5yZXBvc2l0b3J5LT5tYWtlX2VsZW1lbnQoICd1bCcsIGNsYXNzID0+ICdlcF9yZXBvcnRf +aXRlbXMnICkgKTsKCgkJCWZvcmVhY2ggbXkgJHIgKCBAcmVwb3J0X3BsdWdpbnMgKQoJCQl7CgkJ +CQlteSAkc3ViX2xpID0gJGNhdF91bC0+YXBwZW5kQ2hpbGQoICRzZWxmLT5yZXBvc2l0b3J5LT5t +YWtlX2VsZW1lbnQoICdsaScgKSApOwoJCQkJJHN1Yl9saS0+YXBwZW5kQ2hpbGQoICRyLT5yZW5k +ZXJfYWN0aW9uX2xpbmsgKTsKCQkJCSRwcmVzZXRzX2FkZGVkKys7CgkJCX0KCQl9Cgl9CgoJJHBy +ZXNldC0+YXBwZW5kQ2hpbGQoICR1bCApOwoJcHVzaCBAcGFuZWxzLCAkcHJlc2V0OwoKCSNjdXN0 +b20gcmVwb3J0cwoJcHVzaCBAbGFiZWxzLCAkcmVwby0+aHRtbF9waHJhc2UoICJyZXBvcnRzX2N1 +c3RvbSIgKTsKCglteSAkY3VzdG9tID0gJHJlcG8tPm1ha2VfZWxlbWVudCggImRpdiIsIGlkPT4i +Y3VzdG9tX3JlcG9ydCIgKTsKCW15ICRmb3JtID0gJHJlcG8tPnJlbmRlcl9mb3JtKCAiZ2V0IiAp +OwoKCSRmb3JtLT5hcHBlbmRDaGlsZCggJHNlbGYtPnJlbmRlcl9jb250cm9scyggMSApICk7CgoJ +I2FkZCBlYWNoIHJlcG9ydCB0byB0aGUgc2VsZWN0IGNvbXBvbmVudCBhbmQgZ2VuZXJhdGUgc2Vh +cmNoIGZvcm0gaWYgcmVxdWlyZWQKCW15ICRyZXBvcnRfc2VsZWN0ID0gJHJlcG8tPm1ha2VfZWxl +bWVudCggInNlbGVjdCIsIG5hbWU9PiJyZXBvcnQiLCBpZD0+InNlbGVjdF9yZXBvcnQiLCAnYXJp +YS1sYWJlbGxlZGJ5JyA9PiAicmVwb3J0X3NlbGVjdF9sYWJlbCIgKTsKCW15IEBzZWFyY2hfZm9y +bXM7CglteSAkY3VzdG9tX3JlcG9ydHMgPSAwOwoJI2ZvcmVhY2ggbXkgJHJlcG9ydF9wbHVnaW4g +KCBAcGx1Z2lucyApCglmb3JlYWNoIG15ICRyZXBvcnRfcGx1Z2luICggc29ydCB7ICRhLT5nZXRf +c3VidHlwZSBjbXAgJGItPmdldF9zdWJ0eXBlIH0gQHBsdWdpbnMgKQoJewoJCWlmKCAkcmVwb3J0 +X3BsdWdpbi0+cGFyYW0oICJjdXN0b20iICkgKQoJCXsJCgkJCSRjdXN0b21fcmVwb3J0cysrOwoJ +CQlteSAkZm9ybWlkID0gJHJlcG9ydF9wbHVnaW4tPntzY29uZn07CgoJCQkjYWRkIHRvIHNlbGVj +dCBjb21wb25lbnQKCQkJbXkgJGlkID0gJHJlcG9ydF9wbHVnaW4tPntyZXBvcnR9OwoJCQlteSAk +b3B0aW9uID0gJHJlcG8tPm1ha2VfZWxlbWVudCggIm9wdGlvbiIsIHZhbHVlID0+ICRyZXBvcnRf +cGx1Z2luLT5nZXRfc3VidHlwZSwgZm9ybSA9PiAkZm9ybWlkICk7CgoJCQkjc2V0IGRlZmF1bHQg +b3B0aW9uIGZvciBzZWxlY3QgY29tcG9uZW50IGlmIHJlcXVpcmVkIChpLmUuIHdlIGhhdmUgY29t +ZSBmcm9tIGEgcmVmaW5lIHNlYXJjaCBvciBuZXcgc2VhcmNoIGxpbmspCgkJCW15ICRyZWZpbmVf +c2NvbmYgPSAkc2VsZi0+e3Nlc3Npb259LT5wYXJhbSggInNjb25mIiApOwoJCQlpZiggKCAkc2Vs +Zi0+e3Byb2Nlc3Nvcn0tPnthY3Rpb259IGVxICJ1cGRhdGUiIHx8ICRzZWxmLT57cHJvY2Vzc29y +fS0+e2FjdGlvbn0gZXEgIm5ld3NlYXJjaCIgKSAmJiBkZWZpbmVkICRyZWZpbmVfc2NvbmYgJiYg +JHJlZmluZV9zY29uZiBlcSAkZm9ybWlkICkKCQkJewoJCQkJJG9wdGlvbi0+c2V0QXR0cmlidXRl +KCBzZWxlY3RlZCA9PiAic2VsZWN0ZWQiICk7CgkJCX0KCgkJCSNzZXQgb3B0aW9uIHRleHQgYW5k +IGFkZCB0byBzZWxlY3QKICAJCQkkb3B0aW9uLT5hcHBlbmRDaGlsZCggJHJlcG9ydF9wbHVnaW4t +PnJlbmRlcl90aXRsZSApOwoJCQkkcmVwb3J0X3NlbGVjdC0+YXBwZW5kQ2hpbGQoICRvcHRpb24g +KTsKCiAgICAgICAgICAgICMgbm93IHdlJ3ZlIGFkZGVkIHRvIHRoZSBzZWxlY3QsIGRvIHdlIG5l +ZWQgdG8gcmVuZGVyIGEgc2VhcmNoIGZvcm0KICAgICAgICAgICAgbmV4dCBpZiAoZ3JlcCB7ICRm +b3JtaWQgZXEgJF8gfSBAc2VhcmNoX2Zvcm1zICk7ICAgICAKCgkJCSNjcmVhdGUgc2VhcmNoIGZv +cm0JCQkKCQkJI2dldCByZXBvcnQgZGF0YXNldCBhbmQgYXBwcm9wcmlhdGUgc2VhcmNoIGNvbmZp +ZwogICAgICAgICAgICBteSAkc2VhcmNoZGF0YXNldGlkID0gJHJlcG9ydF9wbHVnaW4tPntzZWFy +Y2hkYXRhc2V0aWR9OwogICAgICAgICAgICBpZiggZGVmaW5lZCAkcmVwb3J0X3BsdWdpbi0+cGFy +YW0oInNlYXJjaGRhdGFzZXRpZCIpICkKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgJHNl +YXJjaGRhdGFzZXRpZCA9ICRyZXBvcnRfcGx1Z2luLT5wYXJhbSgic2VhcmNoZGF0YXNldGlkIik7 +CiAgICAgICAgICAgIH0gICAgCgkJCW15ICRyZXBvcnRfZHMgPSAkcmVwby0+ZGF0YXNldCggJHNl +YXJjaGRhdGFzZXRpZCApOwoJCQlteSAkc2NvbmYgPSAkcmVwb3J0X2RzLT5zZWFyY2hfY29uZmln +KCAkcmVwb3J0X3BsdWdpbi0+e3Njb25mfSApIDsKCQkJI215ICRzZWFyY2ggPSBFUHJpbnRzOjpT +ZWFyY2gtPm5ldygKCQkgICAgICAgICMgICAgICAgIGtlZXBfY2FjaGUgPT4gMSwKCSAgICAgICAg +ICAgICAgICAjCXNlc3Npb24gPT4gJHJlcG8sCgkJICAgICAgICAjICAgICAgICBkYXRhc2V0ID0+ +ICRyZXBvcnRfZHMsCgkJICAgICAgICAjICAgICAgICAleyRzY29uZn0KCQkJIyk7CgoJCQlteSAk +Zm9ybWF0ID0gInJlcG9ydC8iIC4gJHJlcG9ydF9kcy0+YmFzZV9pZDsKCSAgICAgICAgICAgICAg +ICBteSAkc2VhcmNoZXhwID0gJHJlcG8tPnBsdWdpbiggIlNlYXJjaCIgKS0+cGx1Z2lucygKICAg +ICAgICAgICAgICAgICAgICAgICAgCXsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAJ +a2VlcF9jYWNoZSA9PiAxLAoJICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzZXNzaW9u +ID0+ICRzZWxmLT57c2Vzc2lvbn0sCiAgICAgICAgCSAgICAgICAgICAgICAgICAgICAgICAgIGRh +dGFzZXQgPT4gJHJlcG9ydF9kcywKICAgICAgICAgICAgICAgIAkgICAgICAgICAgICAgICAgJXsk +c2NvbmZ9CiAgICAgICAgICAgICAgICAgICAgICAgIAl9LAogICAgICAgICAgICAgICAgICAgICAg +ICB0eXBlID0+ICJTZWFyY2giLAogICAgICAgICAgICAgICAgICAgICAgICBjYW5fc2VhcmNoID0+ +ICRmb3JtYXQsCiAgICAgICAgICAgICAgICAJKTsJCgkJCSRzZWFyY2hleHAtPmZyb21fZm9ybTsK +CgkJCSNnZW5lcmF0ZSB0aGUgZm9ybQoJCQlteSAkZnJhZyA9ICRzZWxmLT5yZW5kZXJfc2VhcmNo +X2ZpZWxkcyggJHNlYXJjaGV4cCwgJGZvcm1pZCApOwoKICAgICAgICAgICAgbXkgJHRlbXBsYXRl +ID0gJHJlcG8tPm1ha2VfZWxlbWVudCggInRlbXBsYXRlIiwgaWQgPT4gJGZvcm1pZCApOwogICAg +ICAgICAgICBteSAkdGFibGUgPSAkcmVwby0+bWFrZV9lbGVtZW50KCAiZGl2IiwgY2xhc3M9PiJl +cF90YWJsZSBlcF9zZWFyY2hfZmllbGRzIiwgaWQ9PiJmb3JtXyRmb3JtaWQiICk7CiAgICAgICAg +ICAgICR0YWJsZS0+YXBwZW5kQ2hpbGQoICRmcmFnICk7CiAgICAgICAgICAgICR0ZW1wbGF0ZS0+ +YXBwZW5kQ2hpbGQoICR0YWJsZSApOwogICAgICAgICAgICAkY3VzdG9tLT5hcHBlbmRDaGlsZCgg +JHRlbXBsYXRlICk7CgogICAgICAgICAgICAjIGtlZXAgYSByZWNvcmQgb2YgdGhpcyBzZWFyY2gg +Zm9ybSB0byBzYXZlIHVzIGZyb20gcmVuZGVyaW5nIGl0IGFnYWluCiAgICAgICAgICAgIHB1c2gg +QHNlYXJjaF9mb3JtcywgJGZvcm1pZDsKCQl9CQoJfQoKICAgICMgbGFiZWwgZm9yIGZvcm0gc2Vs +ZWN0IGRyb3AgZG93bgogICAgbXkgJHJlcG9ydF9sYWJlbCA9ICRyZXBvLT5tYWtlX2VsZW1lbnQo +ICJsYWJlbCIsIGlkPT4icmVwb3J0X3NlbGVjdF9sYWJlbCIgKTsKICAgICRyZXBvcnRfbGFiZWwt +PmFwcGVuZENoaWxkKCAkcmVwby0+aHRtbF9waHJhc2UoICJyZXBvcnRfc2VsZWN0X2xhYmVsIiAp +ICk7CiAgICAkZm9ybS0+YXBwZW5kQ2hpbGQoICRyZXBvcnRfbGFiZWwgKTsKCSRmb3JtLT5hcHBl +bmRDaGlsZCggJHJlcG9ydF9zZWxlY3QgKTsKCQogICAgJGZvcm0tPmFwcGVuZENoaWxkKCAkcmVw +by0+cmVuZGVyX2hpZGRlbl9maWVsZCggInNjcmVlbiIsICRzZWxmLT57c2NyZWVuaWR9ICkgKTsK +ICAgICRmb3JtLT5hcHBlbmRDaGlsZCggJHJlcG8tPm1ha2VfZWxlbWVudCggImRpdiIsIGlkPT4i +Zm9ybV9jb250YWluZXIiICkgKTsKCQogICAgJGZvcm0tPmFwcGVuZENoaWxkKCAkc2VsZi0+cmVu +ZGVyX2NvbnRyb2xzICk7CgkKICAgICRjdXN0b20tPmFwcGVuZENoaWxkKCAkZm9ybSApOwoKCSNq +YXZhc2NyaXB0IGZvciBjaGFuZ2luZyBmb3JtcyBiYXNlZCBvbiByZXBvcnQgc2VsZWN0aW9uCgkk +Y3VzdG9tLT5hcHBlbmRDaGlsZCggJHJlcG8tPm1ha2VfamF2YXNjcmlwdCggJ2luaXRSZXBvcnRG +b3JtKCk7JyApICk7CgoJaWYoICRjdXN0b21fcmVwb3J0cyAmJiAkcHJlc2V0c19hZGRlZCA+IDAg +KSAjc2V0IHVwIHRhYiBpbnRlcmZhY2UKCXsKCQlteSBAbGFiZWxzOwoJICAgICAgICBteSBAcGFu +ZWxzOwoKCQlwdXNoIEBsYWJlbHMsICRyZXBvLT5odG1sX3BocmFzZSggInJlcG9ydHNfcHJlc2V0 +IiApOwoJCXB1c2ggQGxhYmVscywgJHJlcG8tPmh0bWxfcGhyYXNlKCAicmVwb3J0c19jdXN0b20i +ICk7CgoJCXB1c2ggQHBhbmVscywgJHByZXNldDsKCQlwdXNoIEBwYW5lbHMsICRjdXN0b207CgoJ +CW15ICVvcHRzOwoJCWlmKCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPnthY3Rpb259IGVxICJuZXdzZWFy +Y2giIHx8ICRzZWxmLT57cHJvY2Vzc29yfS0+e2FjdGlvbn0gZXEgInVwZGF0ZSIgICkKCQl7CgkJ +CSRvcHRze2N1cnJlbnR9ID0gMTsKCQl9CgoJCXJldHVybiAkcmVwby0+eGh0bWwtPnRhYnMoXEBs +YWJlbHMsIFxAcGFuZWxzLCAlb3B0cyApOwoJfQoJZWxzaWYoICRwcmVzZXRzX2FkZGVkID4gMCAp +Cgl7CQoJCXJldHVybiAkcHJlc2V0OwoJfQoJZWxzZQoJewoJCXJldHVybiAkY3VzdG9tOwoJfQp9 +CgpzdWIgcmVuZGVyX3NlYXJjaF9maWVsZHMKewogICAgbXkoICRzZWxmLCAkc2VhcmNoLCAkZm9y +bWlkICkgPSBAXzsKCglteSAkZXhwID0gJHNlbGYtPntzZXNzaW9ufS0+cGFyYW0oICJleHAiICk7 +CglteSAkc2NvbmYgPSAkc2VsZi0+e3Nlc3Npb259LT5wYXJhbSggInNjb25mIiApOwogICAgaWYo +IGRlZmluZWQgJGV4cCAmJiBkZWZpbmVkICRzY29uZiAmJiAkc2NvbmYgZXEgJGZvcm1pZCApCgl7 +CiAgICAgICAgJHNlYXJjaC0+ZnJvbV9zdHJpbmcoICRleHAgKTsKICAJfQoKICAgIG15ICRmcmFn +ID0gJHNlbGYtPntzZXNzaW9ufS0+bWFrZV9kb2NfZnJhZ21lbnQ7CiAgICBmb3JlYWNoIG15ICRz +ZiAoICRzZWFyY2gtPmdldF9ub25fZmlsdGVyX3NlYXJjaGZpZWxkcyApCiAgICB7CiAgICAgICAg +bXkgJGxhYmVsOwogICAgICAgIG15ICRmaWVsZDsKICAgICAgICBpZiAoICRzZi0+eyJmaWVsZCJ9 +LT5nZXRfdHlwZSgpIGVxICJuYW1lZHNldCIgKQogICAgICAgIHsKICAgICAgICAgICAgIyB3ZSB3 +YW50IGEgbGVnZW5kIGFuZCBhIGxhYmVsCiAgICAgICAgICAgICRsYWJlbCA9ICRzZWxmLT57c2Vz +c2lvbn0tPm1ha2VfZWxlbWVudCggInNwYW4iLCBpZD0+JHNmLT5nZXRfZm9ybV9wcmVmaXguIl9s +YWJlbCIgKTsKICAgICAgICAgICAgJGxhYmVsLT5hcHBlbmRDaGlsZCggJHNmLT5yZW5kZXJfbmFt +ZSApOwoKICAgICAgICAgICAgbXkgJGxlZ2VuZCA9IEVQcmludHM6OlV0aWxzOjp0cmVlX3RvX3V0 +ZjgoICRzZi0+cmVuZGVyX25hbWUgKTsKICAgICAgICAgICAgJGZpZWxkID0gJHNmLT5yZW5kZXIo +IGxlZ2VuZCA9PiAkbGVnZW5kICk7CiAgICAgICAgfQogICAgICAgIGVsc2UgewogICAgICAgICAg +ICAkbGFiZWwgPSAkc2VsZi0+e3Nlc3Npb259LT5tYWtlX2VsZW1lbnQoICJzcGFuIiwgaWQ9PiRz +Zi0+Z2V0X2Zvcm1fcHJlZml4LiJfbGFiZWwiICk7CiAgICAgICAgICAgICRsYWJlbC0+YXBwZW5k +Q2hpbGQoICRzZi0+cmVuZGVyX25hbWUgKTsKICAgICAgICAgICAgJGZpZWxkID0gJHNmLT5yZW5k +ZXIoKTsKICAgICAgICB9CgoJICAgICRmcmFnLT5hcHBlbmRDaGlsZCgKICAgICAgICAgICAgJHNl +bGYtPntzZXNzaW9ufS0+cmVuZGVyX3Jvd193aXRoX2hlbHAoCiAgICAgICAgICAgICAgICBoZWxw +X3ByZWZpeCA9PiAkc2YtPmdldF9mb3JtX3ByZWZpeC4iX2hlbHAiLAogICAgICAgICAgICAgICAg +aGVscCA9PiAkc2YtPnJlbmRlcl9oZWxwLAogICAgICAgICAgICAgICAgbGFiZWwgPT4gJGxhYmVs +LAogICAgICAgICAgICAgICAgZmllbGQgPT4gJGZpZWxkLAogICAgICAgICAgICAgICAgbm9fdG9n +Z2xlID0+ICggJHNmLT57c2hvd19oZWxwfSBlcSAiYWx3YXlzIiApLAogICAgICAgICAgICAgICAg +bm9faGVscCA9PiAoICRzZi0+e3Nob3dfaGVscH0gZXEgIm5ldmVyIiApLAogICAgICAgICkgKTsK +ICAgIH0KCiAgICByZXR1cm4gJGZyYWc7Cn0KCnN1YiByZW5kZXJfY29udHJvbHMKewoJbXkoICRz +ZWxmLCAkd2l0aF9qcyApID0gQF87CgogICAgbXkgJGRpdiA9ICRzZWxmLT57c2Vzc2lvbn0tPm1h +a2VfZWxlbWVudCgKICAgICAgICAiZGl2IiAsCiAgICAgICAgY2xhc3MgPT4gImVwX3NlYXJjaF9i +dXR0b25zIiApOwogICAgICAgIAogICAgJGRpdi0+YXBwZW5kQ2hpbGQoICRzZWxmLT57c2Vzc2lv +bn0tPnJlbmRlcl9hY3Rpb25fYnV0dG9ucygKICAgICAgICBfb3JkZXIgPT4gWyAic2VhcmNoIiBd +LAogICAgICAgICNuZXdzZWFyY2ggPT4gJHNlbGYtPntzZXNzaW9ufS0+cGhyYXNlKCAibGliL3Nl +YXJjaGV4cHJlc3Npb246YWN0aW9uX3Jlc2V0IiApLAogICAgICAgIHNlYXJjaCA9PiAkc2VsZi0+ +e3Nlc3Npb259LT5waHJhc2UoICJsaWIvc2VhcmNoZXhwcmVzc2lvbjphY3Rpb25fc2VhcmNoIiAp +ICkKICAgICk7CgkKCW15ICR4bWwgPSAkc2VsZi0+e3Nlc3Npb259LT54bWw7CgoJaWYoICR3aXRo +X2pzICkKCXsKCQlteSAkY2xlYXJfZm9ybSA9ICRkaXYtPmFwcGVuZENoaWxkKCAkc2VsZi0+cmVu +ZGVyX2NsZWFyZm9ybSggJHhtbCApICk7Cgl9CgogICAgbXkgJGNsZWFyX2J0biA9ICRkaXYtPmFw +cGVuZENoaWxkKCAkeG1sLT5jcmVhdGVfZWxlbWVudCggImJ1dHRvbiIsCiAgICAgICAgdHlwZSA9 +PiAiYnV0dG9uIiwKICAgICAgICBvbmNsaWNrID0+ICJjbGVhckZvcm0oKTsiLAogICAgICAgIGNs +YXNzID0+ICJlcF9mb3JtX2FjdGlvbl9idXR0b24gY2xlYXJfYnV0dG9uIiwKICAgICkgKTsKICAg +ICRjbGVhcl9idG4tPmFwcGVuZENoaWxkKCAkeG1sLT5jcmVhdGVfdGV4dF9ub2RlKCAkc2VsZi0+ +e3Nlc3Npb259LT5waHJhc2UoICJsaWIvc2VhcmNoZXhwcmVzc2lvbjphY3Rpb25fcmVzZXQiICkg +KSApOwoJcmV0dXJuICRkaXY7Cn0KCnN1YiByZW5kZXIKewoJbXkoICRzZWxmICkgPSBAXzsKCgkj +IGlmIHVzZXJzIGFjY2VzcyBTY3JlZW46OlJlcG9ydCBkaXJlY3RseSB3ZSB3YW50IHRvIGRpc3Bs +YXkgc29tZSBzb3J0IG9mIG1lbnUKCSMgd2hlcmUgdXNlcnMgY2FuIHNlbGVjdCB2aWV3YWJsZSBy +ZXBvcnRzCglpZiggKCAiRVByaW50czo6UGx1Z2luOjoiLiRzZWxmLT5nZXRfaWQgZXEgX19QQUNL +QUdFX18gJiYgJHNlbGYtPntwcm9jZXNzb3J9LT57YWN0aW9ufSBuZSAic2VhcmNoIiApIHx8ICRz +ZWxmLT57cHJvY2Vzc29yfS0+e2FjdGlvbn0gZXEgIm5ld3NlYXJjaCIgKQoJewkKCQlyZXR1cm4g +JHNlbGYtPnJlbmRlcl9zcGxhc2hfcGFnZTsKCX0KCglteSAkcmVwbyA9ICRzZWxmLT5yZXBvc2l0 +b3J5OwoKCW15ICRjaHVuayA9ICRyZXBvLT5tYWtlX2RvY19mcmFnbWVudDsKCgkkY2h1bmstPmFw +cGVuZENoaWxkKCAkc2VsZi0+cmVuZGVyX2V4cG9ydF9iYXIgKTsKCSRjaHVuay0+YXBwZW5kQ2hp +bGQoICRzZWxmLT5yZW5kZXJfZ3JvdXBfb3B0aW9ucyApOwoJJGNodW5rLT5hcHBlbmRDaGlsZCgg +JHNlbGYtPnJlbmRlcl9zb3J0X29wdGlvbnMgKTsKCglpZiggJHNlbGYtPntwcm9jZXNzb3J9LT57 +YWN0aW9ufSBlcSAic2VhcmNoIiApCgl7CgkJJGNodW5rLT5hcHBlbmRDaGlsZCggJHNlbGYtPnJl +bmRlcl9yZWZpbmVfc2VhcmNoICk7Cgl9CgoJbXkgJGl0ZW1zID0gJHNlbGYtPml0ZW1zOwoJaWYo +ICFkZWZpbmVkICRpdGVtcyB8fCAkaXRlbXMtPmNvdW50ID09IDAgKQoJewoJCSMgTm8gaXRlbXMg +bWVzc2FnZQoJfQoKCW15ICRqc29uOwoKCWlmKCBkZWZpbmVkICRzZWxmLT57cHJvY2Vzc29yfS0+ +e2dyb3VwfSAmJiAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntncm91cH0gbmUgIiIgKQoJewoJCW15ICRn +cm91cGVkID0gJHNlbGYtPmdldF9ncm91cGVkX2l0ZW1zKCAkaXRlbXMsIDEgKTsKCQkkanNvbiA9 +IGVuY29kZV9qc29uICRncm91cGVkOwoJfQoJZWxzZQoJewoJCW15ICRpdGVtX2lkcyA9IGRlZmlu +ZWQgJGl0ZW1zID8gJGl0ZW1zLT5pZHMgOiBbXTsKCQkkanNvbiA9ICJbIi5qb2luKCcsJyxAJGl0 +ZW1faWRzKS4iXSI7Cgl9CgogICAgICAgIG15ICR1cmwgPSAkcmVwby0+Y3VycmVudF91cmwoIGhv +c3QgPT4gMSApOwogICAgICAgIG15ICRwYXJhbWV0ZXJzID0gVVJJLT5uZXc7CiAgICAgICAgJHBh +cmFtZXRlcnMtPnF1ZXJ5X2Zvcm0oCiAgICAgICAgICAgICAgICAkc2VsZi0+aGlkZGVuX2JpdHMs +CiAgICAgICAgKTsKICAgICAgICAkcGFyYW1ldGVycyA9ICRwYXJhbWV0ZXJzLT5xdWVyeTsKCQkK +CW15ICRkcyA9ICRyZXBvLT5kYXRhc2V0KCAkc2VsZi0+cGFyYW0oICdkYXRhc2V0aWQnICkgKSBp +ZiBkZWZpbmVkICRzZWxmLT5wYXJhbSggJ2RhdGFzZXRpZCcgKTsKCW15ICRwcmVmaXggPSAkZHMt +PmJhc2VfaWQgaWYgZGVmaW5lZCAkZHM7CgoJIyB0aGUgbWFpbiA8ZGl2PgoJbXkgJGNvbnRhaW5l +cl9pZCA9IHNwcmludGYoICJlcF9yZXBvcnRfJXNcX2NvbnRhaW5lciIsICRzZWxmLT5nZXRfcmVw +b3J0ICk7CgoJI3VwZGF0ZSBqYXZhc2NyaXB0IHBhcmFtZXRlcnMgaWYgY29taW5nIGZyb20gYSBz +ZWFyY2ggcmVxdWVzdAoJaWYoICRzZWxmLT57cHJvY2Vzc29yfS0+e2FjdGlvbn0gZXEgInNlYXJj +aCIgKQoJewoJCW15ICRwbHVnaW4gPSAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntyZXBvcnR9OwoJCSRw +bHVnaW4gPX4gcy86LyUzQS9nOwoJCSRwYXJhbWV0ZXJzID0gInNjcmVlbj0kcGx1Z2luIjsKCQkk +cHJlZml4ID0gJHNlbGYtPntwcm9jZXNzb3J9LT57ZGF0YXNldGlkfTsKCQkkY29udGFpbmVyX2lk +ID0gc3ByaW50ZiggImVwX3JlcG9ydF8lc1xfY29udGFpbmVyIiwgJHNlbGYtPntwcm9jZXNzb3J9 +LT57cmVwb3J0X3BsdWdpbn0tPntyZXBvcnR9ICk7Cgl9CgkKCSNzaG93L2hpZGUgY29tcGxpYW5j +ZQoJbXkgJHNob3dfY29tcGxpYW5jZSA9IDE7Cgkkc2hvd19jb21wbGlhbmNlID0gJHNlbGYtPntz +aG93X2NvbXBsaWFuY2V9IGlmIGRlZmluZWQgJHNlbGYtPntzaG93X2NvbXBsaWFuY2V9OwoKCSNj +dXN0b20gbGFiZWxzCglteSAkbGFiZWxzID0gMDsKCSRsYWJlbHMgPSBlbmNvZGVfanNvbiAkc2Vs +Zi0+e2xhYmVsc30gaWYgZGVmaW5lZCAkc2VsZi0+e2xhYmVsc307CgoJJGNodW5rLT5hcHBlbmRD +aGlsZCggJHJlcG8tPm1ha2VfamF2YXNjcmlwdCggPDwiRU9KIiApICk7CmRvY3VtZW50Lm9ic2Vy +dmUoImRvbTpsb2FkZWQiLCBmdW5jdGlvbigpIHsKCW5ldyBFUHJpbnRzX1NjcmVlbl9SZXBvcnRf +TG9hZGVyKCB7CgkJaWRzOiAkanNvbiwKCQlzdGVwOiAyMCwKCQlwcmVmaXg6ICckcHJlZml4JywK +CQl1cmw6ICckdXJsJywKCQlwYXJhbWV0ZXJzOiAnJHBhcmFtZXRlcnMnLAkJCgkJY29udGFpbmVy +X2lkOiAnJGNvbnRhaW5lcl9pZCcsCgkJc2hvd19jb21wbGlhbmNlOiAkc2hvd19jb21wbGlhbmNl +LAoJCWxhYmVsczogJGxhYmVscwoJfSApLmV4ZWN1dGUoKTsKCn0pOwpFT0oKCSRjaHVuay0+YXBw +ZW5kQ2hpbGQoICRyZXBvLT5tYWtlX2VsZW1lbnQoICdkaXYnLCBjbGFzcyA9PiAnZXBfcmVwb3J0 +X3BhZ2UnLCBpZCA9PiAkY29udGFpbmVyX2lkICkgKTsKCgkjc2hvdyBzZWFyY2ggY29udHJvbHMg +YWZ0ZXIgdGhlIHJlc3VsdHMgdG9vCglpZiggJHNlbGYtPntwcm9jZXNzb3J9LT57YWN0aW9ufSBl +cSAic2VhcmNoIiApCiAgICAgICAgewogICAgICAgICAgICAgICAgJGNodW5rLT5hcHBlbmRDaGls +ZCggJHNlbGYtPnJlbmRlcl9yZWZpbmVfc2VhcmNoICk7CiAgICAgICAgfQoKCXJldHVybiAkY2h1 +bms7Cn0KCgpzdWIgcmVuZGVyX2V4cG9ydF9iYXIKewoJbXkoICRzZWxmICkgPSBAXzsKCglteSAk +cmVwbyA9ICRzZWxmLT5yZXBvc2l0b3J5OwoKCW15ICRjaHVuayA9ICRyZXBvLT5tYWtlX2RvY19m +cmFnbWVudDsKCglteSBAcGx1Z2lucyA9ICRzZWxmLT5leHBvcnRfcGx1Z2luczsKCXJldHVybiAk +Y2h1bmsgdW5sZXNzKCBzY2FsYXIoIEBwbHVnaW5zICkgfHwgZGVmaW5lZCggJHJlcG8tPmNvbmZp +ZyggJHNlbGYtPntleHBvcnRfY29uZn0sICJleHBvcnRmaWVsZHMiICkgKSApOwoKCW15ICRyZXBv +cnRfZHMgPSAkcmVwby0+ZGF0YXNldCggJHNlbGYtPntkYXRhc2V0aWR9ICk7CglteSAkZm9ybSA9 +ICRzZWxmLT5yZW5kZXJfZm9ybTsKCSRmb3JtLT5zZXRBdHRyaWJ1dGUoIG1ldGhvZCA9PiAiZ2V0 +IiApOwoKCWlmKCBkZWZpbmVkICRzZWxmLT5yZXBvc2l0b3J5LT5wYXJhbSggInNlYXJjaCIgKSB8 +fCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPnthY3Rpb259IGVxICJzZWFyY2giICkKCXsKCQkkZm9ybS0+ +YXBwZW5kQ2hpbGQoICRyZXBvLT5yZW5kZXJfaGlkZGVuX2ZpZWxkKCAic2VhcmNoIiwgICRzZWxm +LT57cHJvY2Vzc29yfS0+e3NlYXJjaH0tPnNlcmlhbGlzZSkgKTsKCX0KCQkKCWlmKCBkZWZpbmVk +ICRzZWxmLT57cHJvY2Vzc29yfS0+e3NvcnR9ICkKCXsKCQkkZm9ybS0+YXBwZW5kQ2hpbGQoICRy +ZXBvLT5yZW5kZXJfaGlkZGVuX2ZpZWxkKCAic29ydCIsICAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntz +b3J0fSApICk7Cgl9CQoKCWlmKCBkZWZpbmVkICRzZWxmLT57cHJvY2Vzc29yfS0+e2dyb3VwX2V4 +cH0gKQoJewoJCSRmb3JtLT5hcHBlbmRDaGlsZCggJHJlcG8tPnJlbmRlcl9oaWRkZW5fZmllbGQo +ICJncm91cCIsICAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntncm91cF9leHB9ICkgKTsKCX0JCgogICAg +bXkgJGV4cG9ydF9sYWJlbCA9ICRyZXBvLT5tYWtlX2VsZW1lbnQoICJsYWJlbCIsIGlkPT4iZXhw +b3J0X3NlbGVjdF9sYWJlbCIgKTsKICAgICRleHBvcnRfbGFiZWwtPmFwcGVuZENoaWxkKCAkcmVw +by0+aHRtbF9waHJhc2UoICJleHBvcnRfc2VsZWN0X2xhYmVsIiApICk7CiAgICAkZm9ybS0+YXBw +ZW5kQ2hpbGQoICRleHBvcnRfbGFiZWwgKTsKCglpZiggIWRlZmluZWQoICRyZXBvLT5jb25maWco +ICRzZWxmLT57ZXhwb3J0X2NvbmZ9LCAiZXhwb3J0ZmllbGRzIiApICkgKQoJewoJCSNubyBjdXN0 +b20gZXhwb3J0IGZpZWxkcyBkZWZpbmVkLCB1c2UgZXhwb3J0IHBsdWdpbnMgZGVzaWduZWQgZm9y +IHRoaXMgcmVwb3J0CgkJbXkgJHNlbGVjdCA9ICRmb3JtLT5hcHBlbmRDaGlsZCggJHJlcG8tPnJl +bmRlcl9vcHRpb25fbGlzdCgKCQkJbmFtZSA9PiAnZXhwb3J0JywKCQkJdmFsdWVzID0+IFttYXAg +eyAkXy0+Z2V0X3N1YnR5cGUgfSBAcGx1Z2luc10sCgkJCWxhYmVscyA9PiB7bWFwIHsgJF8tPmdl +dF9zdWJ0eXBlID0+ICRfLT5nZXRfbmFtZSB9IEBwbHVnaW5zfSwKICAgICAgICAgICAgJ2FyaWEt +bGFiZWxsZWRieScgPT4gImV4cG9ydF9zZWxlY3RfbGFiZWwiLAoJCSkgKTsKCX0KCWVsc2UKCXsK +CQkjcHJvdmlkZSBsaXN0IG9mIGRlZmF1bHQgZXhwb3J0IHBsdWdpbnMgZm9yIHJlcG9ydHMKCQlA +cGx1Z2lucyA9ICRzZWxmLT5leHBvcnRfcGx1Z2lucyggImdlbmVyaWMiICk7CgkJbXkgJHNlbGVj +dCA9ICRmb3JtLT5hcHBlbmRDaGlsZCggJHJlcG8tPnJlbmRlcl9vcHRpb25fbGlzdCgKCQkJbmFt +ZSA9PiAnZXhwb3J0JywKCQkJdmFsdWVzID0+IFttYXAgeyAkXy0+Z2V0X3N1YnR5cGUgfSBAcGx1 +Z2luc10sCgkJCWxhYmVscyA9PiB7bWFwIHsgJF8tPmdldF9zdWJ0eXBlID0+ICRfLT5nZXRfbmFt +ZSB9IEBwbHVnaW5zfSwKICAgICAgICAgICAgJ2FyaWEtbGFiZWxsZWRieScgPT4gImV4cG9ydF9z +ZWxlY3RfbGFiZWwiLAoJCSkgKTsKCgkJI2NyZWF0ZSBsYWJlbHMgYW5kIHBhbmVscyBmb3IgdGFi +YmVkIGludGVyZmFjZWQKCQlteSAkeG1sID0gJHJlcG8tPnhtbDsKCQlteSAkeGh0bWwgPSAkcmVw +by0+eGh0bWw7CgoJCW15ICRzZWxlY3RfYWxsID0gJGZvcm0tPmFwcGVuZENoaWxkKCAkc2VsZi0+ +cmVuZGVyX3NlbGVjdGFsbCggJHhtbCApICk7CgkJbXkgJHNlbGVjdF9idG4gPSAkZm9ybS0+YXBw +ZW5kQ2hpbGQoICR4bWwtPmNyZWF0ZV9lbGVtZW50KCAiYnV0dG9uIiwKCSAgICAgICAgICAgICAg +ICAgICAgdHlwZSA9PiAiYnV0dG9uIiwKCSAgICAgICAgICAgICAgICAgICAgb25jbGljayA9PiAi +dG9nZ2xlQ2hlY2tib3hlcygpOyIsCgkgICAgICAgICAgICAgICAgICAgIGNsYXNzID0+ICJlcF9m +b3JtX2FjdGlvbl9idXR0b24gc2VsZWN0X2J1dHRvbiIsCgkJKSApOwoJICAgICRzZWxlY3RfYnRu +LT5hcHBlbmRDaGlsZCggJHhtbC0+Y3JlYXRlX3RleHRfbm9kZSggJHJlcG8tPnBocmFzZSggInJl +cG9ydF9zZWxlY3QiICkgKSApOwoKCQkjYWxsb3cgdXNlciB0byBjaG9vc2Ugd2hpY2ggZmllbGRz +IHRoZXkgd2FudCB0byBleHBvcnQKCQlteSAkZXhwb3J0X29wdGlvbnMgPSAkcmVwby0+bWFrZV9l +bGVtZW50KCAiZGl2IiApOwoKCQlteSBAa2V5czsKCQlpZiggZGVmaW5lZCAkcmVwby0+Y29uZmln +KCAkc2VsZi0+e2V4cG9ydF9jb25mfSwgImV4cG9ydGZpZWxkX29yZGVyIiApICkKCQl7CgkJCUBr +ZXlzID0gQHskcmVwby0+Y29uZmlnKCAkc2VsZi0+e2V4cG9ydF9jb25mfSwgImV4cG9ydGZpZWxk +X29yZGVyIiApfTsKCQl9CgkJZWxzZQoJCXsKCQkJQGtleXMgPSBrZXlzICV7JHJlcG8tPmNvbmZp +ZyggJHNlbGYtPntleHBvcnRfY29uZn0sICJleHBvcnRmaWVsZHMiICl9OyAKCQl9CgkJZm9yZWFj +aCBteSAka2V5ICggQGtleXMgKQoJCXsKCQkJI2NyZWF0ZSBhIG5ldyBsaXN0CQkJCgkJCW15ICR1 +bCA9ICRyZXBvLT5tYWtlX2VsZW1lbnQoICJ1bCIsCgkgICAgICAgICAgICAgICAgCXN0eWxlID0+ +ICJsaXN0LXN0eWxlLXR5cGU6IG5vbmUiCgkgICAgICAgIAkpOwoJCQkKCQkJbXkgJGNvdW50ID0g +MDsgI2NvdW50IGhvdyBtYW55IGZpZWxkcyB3ZSBhZGQKCQkJZm9yZWFjaCBteSAkZmllbGRuYW1l +KCBAeyRyZXBvLT5jb25maWcoICRzZWxmLT57ZXhwb3J0X2NvbmZ9LCAiZXhwb3J0ZmllbGRzIiAp +LT57JGtleX19ICkKCQkJewoJCQkJaWYoIGRlZmluZWQgJHJlcG8tPmNvbmZpZyggJHNlbGYtPntl +eHBvcnRfY29uZn0sICJjdXN0b21fZXhwb3J0IiApICYmIGV4aXN0cyAkeyRyZXBvLT5jb25maWco +ICRzZWxmLT57ZXhwb3J0X2NvbmZ9LCAiY3VzdG9tX2V4cG9ydCIgKX17JGZpZWxkbmFtZX0gKSAj +d2UgaGF2ZSBhIGN1c3RvbSBleHBvcnQgZnVuY3Rpb24gaW5zdGVhZCAKCQkJCXsKCQkJCQkkY291 +bnQrKzsKCQkJCQkkc2VsZi0+X2V4cG9ydF9maWVsZF9jaGVja2JveCggJHJlcG8sICRmaWVsZG5h +bWUsICR1bCwgJHJlcG8tPmh0bWxfcGhyYXNlKCAiZXhwb3J0ZmllbGRvcHRpb25zOiRmaWVsZG5h +bWUiICkgKTsgCgkJCQl9CgkJCQllbHNpZiggZGVmaW5lZCBFUHJpbnRzOjpVdGlsczo6ZmllbGRf +ZnJvbV9jb25maWdfc3RyaW5nKCAkcmVwb3J0X2RzLCAkZmllbGRuYW1lICkgKQoJCQkJewoJCQkJ +CW15ICRmaWVsZCA9IEVQcmludHM6OlV0aWxzOjpmaWVsZF9mcm9tX2NvbmZpZ19zdHJpbmcoICRy +ZXBvcnRfZHMsICRmaWVsZG5hbWUgKTsKCQkJCQkkY291bnQrKzsKICAgICAgIAkJCSAgICAgICAg +CSRzZWxmLT5fZXhwb3J0X2ZpZWxkX2NoZWNrYm94KCAkcmVwbywgJGZpZWxkbmFtZSwgJHVsLCAk +ZmllbGQtPnJlbmRlcl9uYW1lICk7CgoJCQkJfQoJCQl9CgkJCWlmKCAkY291bnQgKSAjb25seSBh +ZGQgb3B0aW9ucyBpZiB3ZSBoYXZlIGFueSBmaWVsZHMgdG8gc2hvdwoJCQl7CgkJCQlteSAkZGl2 +ID0gJHJlcG8tPm1ha2VfZWxlbWVudCggImRpdiIsIGNsYXNzPT4icmVwb3J0X2V4cG9ydF9vcHRp +b25zIiApOwoJCQkJJGRpdi0+YXBwZW5kQ2hpbGQoIG15ICRoID0gJHJlcG8tPm1ha2VfZWxlbWVu +dCggImRpdiIsIGNsYXNzPT4iY3VzdG9tX2V4cG9ydF9oZWFkZXIiICkgKTsKCQkJCSRoLT5hcHBl +bmRDaGlsZCggJHJlcG8tPmh0bWxfcGhyYXNlKCAiZXhwb3J0ZmllbGRzOiRrZXkiICkgKTsJCgkJ +CQkkZGl2LT5hcHBlbmRDaGlsZCggJHVsICk7CgkJCQkkZXhwb3J0X29wdGlvbnMtPmFwcGVuZENo +aWxkKCAkZGl2ICk7CgkJCX0KICAgICAgIAkJfQoJCSRmb3JtLT5hcHBlbmRDaGlsZCggJGV4cG9y +dF9vcHRpb25zICk7Cgl9CgoJJGZvcm0tPmFwcGVuZENoaWxkKCAKCQkkcmVwby0+cmVuZGVyX2J1 +dHRvbigKCQkJbmFtZSA9PiAiX2FjdGlvbl9leHBvcnQiLAoJCQljbGFzcyA9PiAiZXBfZm9ybV9h +Y3Rpb25fYnV0dG9uIiwKCQkJdmFsdWUgPT4gJHJlcG8tPnBocmFzZSggJ2NnaS91c2Vycy9lZGl0 +X2VwcmludDpleHBvcnQnICkKCSkgKTsKCgkjY3JlYXRlIGEgY29sbGFwc2libGUgYm94CglteSAk +aW1hZ2VzdXJsID0gJHJlcG8tPmN1cnJlbnRfdXJsKCBwYXRoID0+ICJzdGF0aWMiLCAic3R5bGUv +aW1hZ2VzIiApOwoJbXkgJW9wdGlvbnM7Cgkkb3B0aW9uc3tzZXNzaW9ufSA9ICRyZXBvOwogICAg +ICAgICRvcHRpb25ze2lkfSA9ICJlcF9yZXBvcnRfZXhwb3J0IjsKICAgICAgICAkb3B0aW9uc3t0 +aXRsZX0gPSAkcmVwby0+aHRtbF9waHJhc2UoICJleHBvcnRfdGl0bGUiICk7CiAgICAgICAgJG9w +dGlvbnN7Y29sbGFwc2VkfSA9IDE7Cgkkb3B0aW9uc3tjb250ZW50fSA9ICRmb3JtOwogICAgICAg +ICRvcHRpb25ze3Nob3dfaWNvbl91cmx9ID0gIiRpbWFnZXN1cmwvbXVsdGlfZG93bi5wbmciOwoJ +JG9wdGlvbnN7aGlkZV9pY29uX3VybH0gPSAiJGltYWdlc3VybC9tdWx0aV91cC5wbmciOwoKCW15 +ICRib3ggPSAkcmVwby0+bWFrZV9lbGVtZW50KCAiZGl2Iiwgc3R5bGU9PiJ0ZXh0LWFsaWduOiBs +ZWZ0IiwgY2xhc3M9PiRzZWxmLT57cmVwb3J0fSApOwoJJGJveC0+YXBwZW5kQ2hpbGQoIEVQcmlu +dHM6OkJveDo6cmVuZGVyKCAlb3B0aW9ucyApICk7CgkkY2h1bmstPmFwcGVuZENoaWxkKCAkYm94 +ICk7CgoJcmV0dXJuICRjaHVuazsKfQoKc3ViIHJlbmRlcl9zb3J0X29wdGlvbnMKewoJbXkoICRz +ZWxmICkgPSBAXzsKCglteSAkcmVwbyA9ICRzZWxmLT5yZXBvc2l0b3J5OwoKCW15ICRjaHVuayA9 +ICRyZXBvLT5tYWtlX2RvY19mcmFnbWVudDsKCglyZXR1cm4gJGNodW5rIHVubGVzcyggZGVmaW5l +ZCggJHJlcG8tPmNvbmZpZyggJHNlbGYtPntzb3J0X2NvbmZ9LCAic29ydGZpZWxkcyIgKSApICk7 +CgoJbXkgJHNvcnRfY29uZiA9ICRyZXBvLT5jb25maWcoICRzZWxmLT57c29ydF9jb25mfSwgInNv +cnRmaWVsZHMiICk7CgoJI2J1aWxkIHRoZSBmb3JtCglteSAkZm9ybSA9ICRzZWxmLT5yZW5kZXJf +Zm9ybTsKCSRmb3JtLT5zZXRBdHRyaWJ1dGUoIG5hbWUgPT4gInNvcnRfcmVwb3J0IiApOwogICAg +ICAgICRmb3JtLT5zZXRBdHRyaWJ1dGUoIG1ldGhvZCA9PiAiZ2V0IiApOwoJJGNodW5rLT5hcHBl +bmRDaGlsZCggJGZvcm0gKTsKCQoJaWYoIGRlZmluZWQgJHJlcG8tPnBhcmFtKCAic2VhcmNoIiAp +IHx8ICRzZWxmLT57cHJvY2Vzc29yfS0+e2FjdGlvbn0gZXEgInNlYXJjaCIgKQoJewoJCSRmb3Jt +LT5hcHBlbmRDaGlsZCggJHJlcG8tPnJlbmRlcl9oaWRkZW5fZmllbGQoICJzZWFyY2giLCAgJHNl +bGYtPntwcm9jZXNzb3J9LT57c2VhcmNofS0+c2VyaWFsaXNlKSApOwoJfQoKCWlmKCBkZWZpbmVk +ICRzZWxmLT57cHJvY2Vzc29yfS0+e2dyb3VwX2V4cH0gKQoJewoJCSRmb3JtLT5hcHBlbmRDaGls +ZCggJHJlcG8tPnJlbmRlcl9oaWRkZW5fZmllbGQoICJncm91cCIsICAkc2VsZi0+e3Byb2Nlc3Nv +cn0tPntncm91cF9leHB9ICkgKTsKCX0KCgkjZGlzcGxheSB0aGUgbGlua3MgdGhhdCB3aWxsIHRy +aWdnZXIgdGhlIGZvcm0KCW15ICRmaXJzdCA9IDE7CglteSAkc29ydF9saW5rcyA9ICRyZXBvLT5t +YWtlX2RvY19mcmFnbWVudDsKCWZvcmVhY2ggbXkgJHNvcnRfbmFtZSAoIGtleXMgJXskc29ydF9j +b25mfSApCiAgICAgICAgewoJCW15ICRzb3J0X3ZhbHVlID0gJHNvcnRfY29uZi0+eyRzb3J0X25h +bWV9OwoJCWlmKCAkZmlyc3QgKQoJCXsKCQkJJGZvcm0tPmFwcGVuZENoaWxkKCAkcmVwby0+cmVu +ZGVyX2hpZGRlbl9maWVsZCggInNvcnQiLCAkc29ydF92YWx1ZSkgKTsKCQl9CgoJCWlmKCAhJGZp +cnN0ICkKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIAkkc29ydF9saW5rcy0+YXBw +ZW5kQ2hpbGQoICRyZXBvLT5odG1sX3BocmFzZSggIlVwZGF0ZS9WaWV3czpncm91cF9zZXBhcmF0 +b3IiICkgKTsKICAgICAgICAgICAgICAgIH0KCQkKCQlpZiggZGVmaW5lZCAkc2VsZi0+e3Byb2Nl +c3Nvcn0tPntzb3J0fSAmJiAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntzb3J0fSBlcSAkc29ydF92YWx1 +ZSApCgkJewoJCQlteSAkc3Ryb25nID0gJHJlcG8tPm1ha2VfZWxlbWVudCggInN0cm9uZyIgKTsK +CQkJJHN0cm9uZy0+YXBwZW5kQ2hpbGQoICRyZXBvLT5odG1sX3BocmFzZSggJHNlbGYtPntzb3J0 +X2NvbmZ9IC4gIjpzb3J0OiIgLiAkc29ydF9uYW1lICkgKTsKCQkJJHNvcnRfbGlua3MtPmFwcGVu +ZENoaWxkKCAkc3Ryb25nICk7CgkJfQoJCWVsc2UKCQl7CgkJCW15ICRsaW5rID0gJHJlcG8tPnJl +bmRlcl9saW5rKCAnamF2YXNjcmlwdDpzb3J0X3JlcG9ydCgiJy4kc29ydF92YWx1ZS4nIiknICk7 +CQoJCQkkbGluay0+YXBwZW5kQ2hpbGQoICRyZXBvLT5odG1sX3BocmFzZSggJHNlbGYtPntzb3J0 +X2NvbmZ9IC4gIjpzb3J0OiIgLiAkc29ydF9uYW1lICkgKTsKCQkJJHNvcnRfbGlua3MtPmFwcGVu +ZENoaWxkKCAkbGluayApOwoJCX0KCQkkZmlyc3QgPSAwOwogICAgICAgIH0gICAgICAgICAgIAoJ +JGNodW5rLT5hcHBlbmRDaGlsZCggJHJlcG8tPmh0bWxfcGhyYXNlKCAiUmVwb3J0OnNvcnRfbGlu +a3MiLCBsaW5rcz0+JHNvcnRfbGlua3MgKSApOwoJcmV0dXJuICRjaHVuazsKfQoKc3ViIHJlbmRl +cl9ncm91cF9vcHRpb25zCnsKCW15KCAkc2VsZiApID0gQF87CgoJbXkgJHJlcG8gPSAkc2VsZi0+ +cmVwb3NpdG9yeTsKCglteSAkY2h1bmsgPSAkcmVwby0+bWFrZV9kb2NfZnJhZ21lbnQ7CgoJcmV0 +dXJuICRjaHVuayB1bmxlc3MoIGRlZmluZWQoICRyZXBvLT5jb25maWcoICRzZWxmLT57Z3JvdXBf +Y29uZn0sICJncm91cGZpZWxkcyIgKSApICk7CgoJbXkgJGdyb3VwX2NvbmYgPSAkcmVwby0+Y29u +ZmlnKCAkc2VsZi0+e2dyb3VwX2NvbmZ9LCAiZ3JvdXBmaWVsZHMiICk7CgoJI2J1aWxkIHRoZSBm +b3JtCglteSAkZm9ybSA9ICRzZWxmLT5yZW5kZXJfZm9ybTsKCSRmb3JtLT5zZXRBdHRyaWJ1dGUo +IG5hbWUgPT4gImdyb3VwX3JlcG9ydCIgKTsKICAgICAgICAkZm9ybS0+c2V0QXR0cmlidXRlKCBt +ZXRob2QgPT4gImdldCIgKTsKCSRjaHVuay0+YXBwZW5kQ2hpbGQoICRmb3JtICk7CgkKCWlmKCBk +ZWZpbmVkICRyZXBvLT5wYXJhbSggInNlYXJjaCIgKSB8fCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPnth +Y3Rpb259IGVxICJzZWFyY2giICkKCXsKCQkkZm9ybS0+YXBwZW5kQ2hpbGQoICRyZXBvLT5yZW5k +ZXJfaGlkZGVuX2ZpZWxkKCAic2VhcmNoIiwgICRzZWxmLT57cHJvY2Vzc29yfS0+e3NlYXJjaH0t +PnNlcmlhbGlzZSkgKTsKCX0KCglpZiggZGVmaW5lZCAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntzb3J0 +fSApCgl7CgkJJGZvcm0tPmFwcGVuZENoaWxkKCAkcmVwby0+cmVuZGVyX2hpZGRlbl9maWVsZCgg +InNvcnQiLCAgJHNlbGYtPntwcm9jZXNzb3J9LT57c29ydH0gKSApOwoJfQoKCSNkaXNwbGF5IHRo +ZSBsaW5rcyB0aGF0IHdpbGwgdHJpZ2dlciB0aGUgZm9ybQoJbXkgJGZpcnN0ID0gMTsKCW15ICRn +cm91cF9saW5rcyA9ICRyZXBvLT5tYWtlX2RvY19mcmFnbWVudDsKCWZvcmVhY2ggbXkgJGdyb3Vw +X3ZhbHVlICggQHskZ3JvdXBfY29uZn0gKQogICAgICAgIHsKCQlteSAoJGdyb3VwX2ZpZWxkKSA9 +IHNwbGl0KC87LywgJGdyb3VwX3ZhbHVlICk7CgkJaWYoICRmaXJzdCApCgkJewoJCQkkZm9ybS0+ +YXBwZW5kQ2hpbGQoICRyZXBvLT5yZW5kZXJfaGlkZGVuX2ZpZWxkKCAiZ3JvdXAiLCAkZ3JvdXBf +dmFsdWUpICk7CgkJfQoKCQlpZiggISRmaXJzdCApCiAgICAgICAgICAgICAgICB7CiAgICAgICAg +ICAgICAgICAJJGdyb3VwX2xpbmtzLT5hcHBlbmRDaGlsZCggJHJlcG8tPmh0bWxfcGhyYXNlKCAi +VXBkYXRlL1ZpZXdzOmdyb3VwX3NlcGFyYXRvciIgKSApOwogICAgICAgICAgICAgICAgfQoJCQoJ +CWlmKCBkZWZpbmVkICRzZWxmLT57cHJvY2Vzc29yfS0+e2dyb3VwfSAmJiAkc2VsZi0+e3Byb2Nl +c3Nvcn0tPntncm91cH0gZXEgJGdyb3VwX2ZpZWxkICkKCQl7CgkJCW15ICRzdHJvbmcgPSAkcmVw +by0+bWFrZV9lbGVtZW50KCAic3Ryb25nIiApOwoJCQkkc3Ryb25nLT5hcHBlbmRDaGlsZCggJHJl +cG8tPmh0bWxfcGhyYXNlKCAkc2VsZi0+e2dyb3VwX2NvbmZ9IC4gIjpncm91cDoiIC4gJGdyb3Vw +X2ZpZWxkICkgKTsKCQkJJGdyb3VwX2xpbmtzLT5hcHBlbmRDaGlsZCggJHN0cm9uZyApOwoJCX0K +CQllbHNlCgkJewoJCQlteSAkbGluayA9ICRyZXBvLT5yZW5kZXJfbGluayggJ2phdmFzY3JpcHQ6 +Z3JvdXBfcmVwb3J0KCInLiRncm91cF92YWx1ZS4nIiknICk7CQoJCQkkbGluay0+YXBwZW5kQ2hp +bGQoICRyZXBvLT5odG1sX3BocmFzZSggJHNlbGYtPntncm91cF9jb25mfSAuICI6Z3JvdXA6IiAu +ICRncm91cF9maWVsZCApICk7CgkJCSRncm91cF9saW5rcy0+YXBwZW5kQ2hpbGQoICRsaW5rICk7 +CgkJfQoJCSRmaXJzdCA9IDA7CiAgICAgICAgfSAgICAgICAgICAgCgkKCSNubyBncm91cGluZyBs +aW5rIGF0IHRoZSBlbmQKCSRncm91cF9saW5rcy0+YXBwZW5kQ2hpbGQoICRyZXBvLT5odG1sX3Bo +cmFzZSggIlVwZGF0ZS9WaWV3czpncm91cF9zZXBhcmF0b3IiICkgKTsKCWlmKCBkZWZpbmVkICRz +ZWxmLT57cHJvY2Vzc29yfS0+e2dyb3VwfSAmJiAkc2VsZi0+e3Byb2Nlc3Nvcn0tPntncm91cH0g +bmUgIiIgKQoJewoJCW15ICRsaW5rID0gJHJlcG8tPnJlbmRlcl9saW5rKCAnamF2YXNjcmlwdDpn +cm91cF9yZXBvcnQoIiIpJyApOwkKCQkkbGluay0+YXBwZW5kQ2hpbGQoICRyZXBvLT5odG1sX3Bo +cmFzZSggInJlcG9ydDpub19ncm91cGluZyIgKSApOwoJCSRncm91cF9saW5rcy0+YXBwZW5kQ2hp +bGQoICRsaW5rICk7Cgl9CgllbHNlCgl7CgkJbXkgJHN0cm9uZyA9ICRyZXBvLT5tYWtlX2VsZW1l +bnQoICJzdHJvbmciICk7CiAJCSRzdHJvbmctPmFwcGVuZENoaWxkKCAkcmVwby0+aHRtbF9waHJh +c2UoICJyZXBvcnQ6bm9fZ3JvdXBpbmciICkgKTsKCQkkZ3JvdXBfbGlua3MtPmFwcGVuZENoaWxk +KCAkc3Ryb25nICk7Cgl9CgkKCSRjaHVuay0+YXBwZW5kQ2hpbGQoICRyZXBvLT5odG1sX3BocmFz +ZSggIlJlcG9ydDpncm91cF9saW5rcyIsIGxpbmtzPT4kZ3JvdXBfbGlua3MgKSApOwoKCXJldHVy +biAkY2h1bms7Cn0KCnN1YiByZW5kZXJfcmVmaW5lX3NlYXJjaAp7CglteSggJHNlbGYgKSA9IEBf +OwoKCW15ICRyZXBvID0gJHNlbGYtPnJlcG9zaXRvcnk7CgoJbXkgJGNodW5rID0gJHJlcG8tPm1h +a2VfZG9jX2ZyYWdtZW50OwoJCglpZiggZGVmaW5lZCAkcmVwby0+cGFyYW0oICJzZWFyY2giICkg +fHwgJHNlbGYtPntwcm9jZXNzb3J9LT57YWN0aW9ufSBlcSAic2VhcmNoIiApCgl7CgkJbXkgJGVz +Y2V4cCA9ICRzZWxmLT57cHJvY2Vzc29yfS0+e3NlYXJjaH0tPnNlcmlhbGlzZTsKCQlteSAkY2Fj +aGVpZCA9ICRyZXBvLT5wYXJhbSggImNhY2hlIiApOwoJCW15ICRzY29uZiA9ICRzZWxmLT57c2Nv +bmZ9OwkKCgkJI3NldCB1cCBuZXcgc2VhcmNoIGxpbmsKCQlteSAkbmV3X2Jhc2V1cmwgPSBVUkkt +Pm5ldyggJHNlbGYtPntzZXNzaW9ufS0+Z2V0X3VyaSApOwogICAgICAgIAkkbmV3X2Jhc2V1cmwt +PnF1ZXJ5X2Zvcm0oCgkgICAgICAgICAgICAgICAgc2NyZWVuID0+ICJSZXBvcnQiLAoJCQlzY29u +ZiA9PiAkc2NvbmYsCiAgICAgICAgCSk7CgoJCW15ICRzZWFyY2hfbGlua3MgPSAkcmVwby0+bWFr +ZV9kb2NfZnJhZ21lbnQ7CgkJbXkgJG5ld19saW5rID0gJHJlcG8tPnJlbmRlcl9saW5rKCAiJG5l +d19iYXNldXJsJl9hY3Rpb25fbmV3c2VhcmNoPTEiICk7CgkgICAJJG5ld19saW5rLT5hcHBlbmRD +aGlsZCggJHJlcG8tPmh0bWxfcGhyYXNlKCAibGliL3NlYXJjaGV4cHJlc3Npb246bmV3IiApICk7 +CgkJJHNlYXJjaF9saW5rcy0+YXBwZW5kQ2hpbGQoICRuZXdfbGluayApOwoKCQkjYWRkIGEgc2Vw +YXJhdG9yLi4uCgkJJHNlYXJjaF9saW5rcy0+YXBwZW5kQ2hpbGQoICRyZXBvLT5odG1sX3BocmFz +ZSggIlVwZGF0ZS9WaWV3czpncm91cF9zZXBhcmF0b3IiICkgKTsKCgkJI3NldCB1cCByZWZpbmUg +c2VhcmNoIGxpbmsKCQlteSAkcmVmaW5lX2Jhc2V1cmwgPSBVUkktPm5ldyggJHNlbGYtPntzZXNz +aW9ufS0+Z2V0X3VyaSApOwogICAgICAgIAkkcmVmaW5lX2Jhc2V1cmwtPnF1ZXJ5X2Zvcm0oCgkg +ICAgICAgIAljYWNoZSA9PiAkY2FjaGVpZCwKCSAgICAgICAgICAgICAgICBleHAgPT4gJGVzY2V4 +cCwKICAgICAgICAJICAgICAgICBzY3JlZW4gPT4gIlJlcG9ydCIsCiAgICAgICAgICAgICAgICAJ +ZGF0YXNldCA9PiAkc2VsZi0+e2RhdGFzZXRpZH0sCiAgICAgICAgICAgICAgICAJb3JkZXIgPT4g +JHNlbGYtPntwcm9jZXNzb3J9LT57c2VhcmNofS0+e2N1c3RvbV9vcmRlcn0sCgkJCXNjb25mID0+ +ICRzY29uZiwKICAgICAgICAJKTsKCgkJbXkgJHJlZmluZV9saW5rID0gJHJlcG8tPnJlbmRlcl9s +aW5rKCAiJHJlZmluZV9iYXNldXJsJl9hY3Rpb25fdXBkYXRlPTEiICk7CiAgICAgIAkJJHJlZmlu +ZV9saW5rLT5hcHBlbmRDaGlsZCggJHJlcG8tPmh0bWxfcGhyYXNlKCAibGliL3NlYXJjaGV4cHJl +c3Npb246cmVmaW5lIiApICk7ICAgCSAgICAgICAgIAoJICAgICAgICAkc2VhcmNoX2xpbmtzLT5h +cHBlbmRDaGlsZCggJHJlZmluZV9saW5rICk7CgoJCSRjaHVuay0+YXBwZW5kQ2hpbGQoICRyZXBv +LT5odG1sX3BocmFzZSggIlJlcG9ydDpzZWFyY2hfbGlua3MiLCBsaW5rcz0+JHNlYXJjaF9saW5r +cyApICk7Cgl9CgoJcmV0dXJuICRjaHVuazsKfQoKCiNhZGRzIGEgbmV3IGNoZWNrYm94IHRvIGFs +bG93IHRoZSB1c2VyIHRvIGNob29zZSB3aGljaCBmaWVsZHMgdG8gZXhwb3J0CnN1YiBfZXhwb3J0 +X2ZpZWxkX2NoZWNrYm94CnsKCW15KCAkc2VsZiwgJHJlcG8sICRmaWVsZG5hbWUsICR1bCwgJGZp +ZWxkbGFiZWwgKSA9IEBfOwoKCW15ICRsaSA9ICRyZXBvLT5tYWtlX2VsZW1lbnQoICJsaSIgKTsK +CSR1bC0+YXBwZW5kQ2hpbGQoICRsaSApOwoKICAgICAgICBteSAkY2hlY2tib3ggPSAkcmVwby0+ +bWFrZV9lbGVtZW50KCAiaW5wdXQiLCB0eXBlID0+ICJjaGVja2JveCIsIGlkID0+ICRmaWVsZG5h +bWUsIG5hbWUgPT4gJGZpZWxkbmFtZSwgdmFsdWUgPT4gJGZpZWxkbmFtZSApOwoJaWYoIGRlZmlu +ZWQgJHJlcG8tPmNvbmZpZyggJHNlbGYtPntleHBvcnRfY29uZn0sICJleHBvcnRmaWVsZF9kZWZh +dWx0cyIgKSApCgl7CgkJaWYoICggZ3JlcCB7ICRmaWVsZG5hbWUgZXEgJF8gfSBAeyRyZXBvLT5j +b25maWcoICRzZWxmLT57ZXhwb3J0X2NvbmZ9LCAiZXhwb3J0ZmllbGRfZGVmYXVsdHMiICl9ICkg +fHwgKCBzY2FsYXIoIEB7JHJlcG8tPmNvbmZpZyggJHNlbGYtPntleHBvcnRfY29uZn0sICJleHBv +cnRmaWVsZF9kZWZhdWx0cyIgKX0gKSA9PSAwICkgKQoJCXsKCQkJIyBjaGVjayBkZWZhdWx0cyBh +cyBzcGVjaWZpZWQKCQkJJGNoZWNrYm94LT5zZXRBdHRyaWJ1dGUoICJjaGVja2VkIiwgInllcyIg +KTsKCQl9Cgl9CiAgICBlbHNlICMgZGVmYXVsdHMgbm90IGRlZmluZWQKICAgIHsKICAgICAgICAk +Y2hlY2tib3gtPnNldEF0dHJpYnV0ZSggImNoZWNrZWQiLCAieWVzIiApOwogICAgfQoKCW15ICRs +YWJlbCA9ICRyZXBvLT5tYWtlX2VsZW1lbnQoICJsYWJlbCIsIGZvciA9PiAkZmllbGRuYW1lICk7 +CgkkbGFiZWwtPmFwcGVuZENoaWxkKCAkZmllbGRsYWJlbCApOwoKCSRsaS0+YXBwZW5kQ2hpbGQo +ICRjaGVja2JveCApOwoJJGxpLT5hcHBlbmRDaGlsZCggJGxhYmVsICk7Cn0KCiMjIyB1dGlsaXR5 +IG1ldGhvZHMKCiMgVE9ETyBzaG91bGQgdXNlICJKU09OIiBwYWNrYWdlCnN1YiB0b19qc29uCnsK +ICAgICAgICBteSggJHNlbGYsICRvYmplY3QgKSA9IEBfOwoKCXJldHVybiAiIiBpZiggIWRlZmlu +ZWQgJG9iamVjdCApOwoKIyBVVEYtOCBpc3N1ZXM6CiMJcmV0dXJuIEpTT04tPm5ldy0+dXRmOCgx +KS0+ZW5jb2RlKCAkb2JqZWN0ICk7CgogICAgICAgIGlmKCByZWYoICRvYmplY3QgKSBlcSAnSEFT +SCcgKQogICAgICAgIHsKICAgICAgICAgICAgICAgIG15IEBzdHVmZjsKICAgICAgICAgICAgICAg +IHdoaWxlKCBteSggJGssICR2ICkgPSBlYWNoKCAlJG9iamVjdCApICkKICAgICAgICAgICAgICAg +IHsKICAgICAgICAgICAgICAgICAgICAgICAgbmV4dCBpZiggIUVQcmludHM6OlV0aWxzOjppc19z +ZXQoICR2ICkgKTsgICAgICAgIyBvciAnbnVsbCcgPwogICAgICAgICAgICAgICAgICAgICAgICBw +dXNoIEBzdHVmZiwgRVByaW50czo6VXRpbHM6OmpzX3N0cmluZyggJGsgKS4nOicuJHNlbGYtPnRv +X2pzb24oICR2ICkKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIHJldHVybiAneycg +LiBqb2luKCAiLCIsIEBzdHVmZiApIC4gJ30nOwogICAgICAgIH0KICAgICAgICBlbHNpZiggcmVm +KCAkb2JqZWN0ICkgZXEgJ0FSUkFZJyApCiAgICAgICAgewogICAgICAgICAgICAgICAgbXkgQHN0 +dWZmOwogICAgICAgICAgICAgICAgZm9yZWFjaCggQCRvYmplY3QgKQogICAgICAgICAgICAgICAg +ewogICAgICAgICAgICAgICAgICAgICAgICBuZXh0IGlmKCAhRVByaW50czo6VXRpbHM6OmlzX3Nl +dCggJF8gKSApOwogICAgICAgICAgICAgICAgICAgICAgICBwdXNoIEBzdHVmZiwgJHNlbGYtPnRv +X2pzb24oICRfICk7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICByZXR1cm4gJ1sn +IC4gam9pbiggIiwiLCBAc3R1ZmYgKSAuICddJzsKICAgICAgICB9CgogICAgICAgIHJldHVybiBF +UHJpbnRzOjpVdGlsczo6anNfc3RyaW5nKCAkb2JqZWN0ICk7Cn0KCnN1YiBleHBvcnRfcGx1Z2lu +cwp7CiAgICAgICAgbXkoICRzZWxmLCAkZ2VuZXJpYyApID0gQF87CgoJbXkgQHBsdWdpbl9pZHM7 +CgkKCW15ICRyZXBvID0gJHNlbGYtPnJlcG9zaXRvcnk7CgoJaWYoIGRlZmluZWQgJHJlcG8tPmNv +bmZpZyggJHNlbGYtPntleHBvcnRfY29uZn0sICJleHBvcnRfcGx1Z2lucyIgKSApCgl7CgkJQHBs +dWdpbl9pZHMgPSBAeyRyZXBvLT5jb25maWcoICRzZWxmLT57ZXhwb3J0X2NvbmZ9LCAiZXhwb3J0 +X3BsdWdpbnMiICl9OwoJfQkKCWVsc2lmKCAkZ2VuZXJpYyApCgl7CiAJCUBwbHVnaW5faWRzID0g +JHJlcG8tPnBsdWdpbl9saXN0KAogICAgICAgICAgICAgICAgCXR5cGUgPT4gIkV4cG9ydCIsCgkg +ICAgICAgICAgICAgICAgY2FuX2FjY2VwdCA9PiAicmVwb3J0L2dlbmVyaWMiLAogICAgICAgIAkg +ICAgICAgIGlzX3Zpc2libGUgPT4gInN0YWZmIiwKCQkJaXNfYWR2ZXJ0aXNlZCA9PiAxLAoJICAg +ICAgICApOwoJfQoJZWxzZQoJewogICAgICAgIAlAcGx1Z2luX2lkcyA9ICRyZXBvLT5wbHVnaW5f +bGlzdCgKICAgICAgICAgICAgICAgIAl0eXBlID0+ICJFeHBvcnQiLAoJICAgICAgICAgICAgICAg +IGNhbl9hY2NlcHQgPT4gInJlcG9ydC8iLiRzZWxmLT5nZXRfcmVwb3J0LAogICAgICAgIAkgICAg +ICAgIGlzX3Zpc2libGUgPT4gInN0YWZmIiwKCQkJaXNfYWR2ZXJ0aXNlZCA9PiAxLAoJICAgICAg +ICApOwogICAgICAgIH0KCW15IEBwbHVnaW5zOwoJZm9yZWFjaCBteSAkaWQgKCBAcGx1Z2luX2lk +cyApCiAgICAgICAgewogICAgICAgICAgICAgICAgbXkgJHAgPSAkcmVwby0+cGx1Z2luKCAiJGlk +IiApIG9yIG5leHQ7CiAgICAgICAgICAgICAgICBwdXNoIEBwbHVnaW5zLCAkcDsKICAgICAgICB9 +CgogICAgICAgIHJldHVybiBAcGx1Z2luczsKfQoKc3ViIHJlcG9ydF9wbHVnaW5zCnsKCW15KCAk +c2VsZiApID0gQF87CgoJIyBzZjIgLSBjYW4ndCBsaXN0IHZpYSB0eXBlID0+ICJTZWFyY2g6OlJl +cG9ydCIgPyAKICAgICAgICBteSBAcGx1Z2luX2lkcyA9ICRzZWxmLT5yZXBvc2l0b3J5LT5wbHVn +aW5fbGlzdCgKICAgICAgICAgICAgICAgIHR5cGUgPT4gIlNjcmVlbiIsCiAgICAgICAgKTsKCiAg +ICAgICAgbXkgQHBsdWdpbnM7Cglmb3JlYWNoIG15ICRpZCAoIEBwbHVnaW5faWRzICkKICAgICAg +ICB7CgkJbmV4dCBpZiggJGlkICF+IC9eU2NyZWVuOjpSZXBvcnQ6Oi8gKTsJIyBub3RlIHRoaXMg +YWxzbyBmaWx0ZXJzIG91dCAkc2VsZiAoYWthIFNjcmVlbjo6UmVwb3J0KQoKICAgICAgICAgICAg +ICAgIG15ICRwID0gJHNlbGYtPnJlcG9zaXRvcnktPnBsdWdpbiggIiRpZCIgKTsKCQluZXh0IGlm +KCAhZGVmaW5lZCAkcCB8fCAhJHAtPmNhbl9iZV92aWV3ZWQgKTsKCiAgICAgICAgICAgICAgICBw +dXNoIEBwbHVnaW5zLCAkcDsKICAgICAgICB9CgogICAgICAgIHJldHVybiBAcGx1Z2luczsKfQoK +I3JldHVybnMgYSBoYXNoIG9mIHZhbHVlcyBtYXBwZWQgdG8gYSBsYWJlbCBhbmQgYSBsaXN0CiNp +ZiBpZHNfb25seSBpcyBzZXQgdGhlIGxpc3Qgb2YgaXRlbXMgYXJlIGp1c3QgcmVwcmVzZW50ZWQg +YnkgdGhlaXIgaWQgKHVzZWQgYnkgcmVwb3J0IEpTKQpzdWIgZ2V0X2dyb3VwZWRfaXRlbXMKewoJ +bXkoICRzZWxmLCAkaXRlbXMsICRpZHNfb25seSApID0gQF87CglteSAkc2Vzc2lvbiA9ICRzZWxm +LT57c2Vzc2lvbn07CglteSAlZ3JvdXBlZDsKCglteSAkZ3JvdXBpbmcgPSAkc2VsZi0+e3Byb2Nl +c3Nvcn0tPntncm91cH07CgoJbXkgJG1ldGFmaWVsZCA9ICRpdGVtcy0+Z2V0X2RhdGFzZXQtPmZp +ZWxkKCAkZ3JvdXBpbmcgKTsKCgkjc2V0IGdyb3VwX29wdHMgaWYgYXBwcm9wcmlhdGUKCWlmKCBk +ZWZpbmVkICRzZWxmLT57cHJvY2Vzc29yfS0+e2dyb3VwX29wdHN9ICkKCXsKCQlpZiggJG1ldGFm +aWVsZC0+dHlwZSBlcSAiZGF0ZSIgKQoJCXsKCQkJJG1ldGFmaWVsZC0+e3JlbmRlcl9yZXN9ID0g +JHNlbGYtPntwcm9jZXNzb3J9LT57Z3JvdXBfb3B0c30tPntyZXN9IGlmIGV4aXN0cyAkc2VsZi0+ +e3Byb2Nlc3Nvcn0tPntncm91cF9vcHRzfS0+e3Jlc307CgkJfQoJfQoKCSNjcmVhdGUgYSBoYXNo +IG9mIGZpZWxkIHZhbHVlcyB0byBpdGVtcyAob3IgaXRlbSBpZHMpCgkkaXRlbXMtPm1hcCggc3Vi +IHsKCSAgICAgICAJbXkoICRzZXNzaW9uLCAkZGF0YXNldCwgJGl0ZW0gKSA9IEBfOwoJCQoJCW15 +ICRtdWx0aXBsZSA9ICRtZXRhZmllbGQtPmdldF9wcm9wZXJ0eSggIm11bHRpcGxlIiApOwoJCW15 +IEBncm91cF92YWx1ZXM7CgkJaWYoICRtdWx0aXBsZSApCiAgICAgICAgICAgICAgICB7CgkJCUBn +cm91cF92YWx1ZXMgPSBAeyRpdGVtLT52YWx1ZSggJGdyb3VwaW5nICl9OwoJCX0KCQllbHNlCgkJ +ewkJCQoJCQlAZ3JvdXBfdmFsdWVzID0gKCRpdGVtLT52YWx1ZSggJGdyb3VwaW5nICkpOwoJCX0K +CQoJCWlmKCBzY2FsYXIgQGdyb3VwX3ZhbHVlcyA+IDAgKQoJCXsKCQkJZm9yZWFjaCBteSAkZ3Jv +dXBfdmFsdWUgKCBAZ3JvdXBfdmFsdWVzICkKCQkJewoJCQkJbXkgJGdyb3VwX2lkID0gJG1ldGFm +aWVsZC0+Z2V0X2lkX2Zyb21fdmFsdWUoICRzZXNzaW9uLCAkZ3JvdXBfdmFsdWUgKTsKCQkJCSN0 +cnVuY2F0ZSBncm91cCBpZiBhcHByb3ByaWF0ZQoJCQkJaWYoIGRlZmluZWQgJHNlbGYtPntwcm9j +ZXNzb3J9LT57Z3JvdXBfb3B0c30gKQoJCQkJewoJCQkJCSRncm91cF9pZCA9ICBzdWJzdHIoICJc +dSRncm91cF9pZCIsIDAsICRzZWxmLT57cHJvY2Vzc29yfS0+e2dyb3VwX29wdHN9LT57dHJ1bmNh +dGV9ICkgaWYgZXhpc3RzICRzZWxmLT57cHJvY2Vzc29yfS0+e2dyb3VwX29wdHN9LT57dHJ1bmNh +dGV9OwoJCQkJfQoKCQkgICAgICAgIAlpZiggZXhpc3RzICRncm91cGVkeyRncm91cF9pZH0gKSAj +d2UndmUgYWxyZWFkeSBzZXQgdGhpcyBsaXN0IHVwLCBwdXNoIGEgbmV3IGl0ZW0gb24gdG8gdGhl +IGxpc3QKCQkgICAgICAgICAgICAgICAJewoJCQkJCWlmKCAkaWRzX29ubHkgKSAjc29tZXRpbWVz +IHdlIG9ubHkgd2FudCBpZHMgcmF0aGVyIHRoYW4gdGhlIHdob2xlIGl0ZW0KCQkJCQl7CgkJCQkJ +CXB1c2ggQHskZ3JvdXBlZHskZ3JvdXBfaWR9fSwgJGl0ZW0tPmlkOwoJCQkJCX0KCQkJCQllbHNl +CgkJCQkJewoJCQkJCQlwdXNoIEB7JGdyb3VwZWR7JGdyb3VwX2lkfX0sICRpdGVtOwoJCQkJCX0K +CSAgICAgICAJCSAgICAgICAgfQogICAgICAgIAkgICAgICAJCWVsc2UgI3NldCB1cCBhIGxpc3Qg +Zm9yIHRoaXMgZ3JvdXAKCSAgICAgICAgCSAgICAgICAJewoJCQkJCW15IEBncm91cGVkX2l0ZW1z +OwoJCQkJCWlmKCAkaWRzX29ubHkgKSAjc29tZXRpbWVzIHdlIG9ubHkgd2FudCBpZHMgcmF0aGVy +IHRoYW4gdGhlIHdob2xlIGl0ZW0KCQkgICAgICAgICAgICAgICAgICAgICAgICB7CQogICAgICAg +IAkJICAgICAgICAgICAgICAgICAgICAgICAgQGdyb3VwZWRfaXRlbXMgPSAoJGl0ZW0tPmlkKTsK +ICAgICAgICAgICAgICAgIAkJICAgICAgICB9CgkgICAgICAgICAgICAgICAgCSAgICAgICAgZWxz +ZQogICAgICAgIAkgICAgICAgICAgICAgICAgCXsKCSAgICAgICAgICAgICAgICAJICAgICAgICAg +ICAgICAgIEBncm91cGVkX2l0ZW1zID0gKCRpdGVtKTsKICAgICAgICAJCSAgICAgICAgICAgICAg +IAl9CgkgICAgICAgICAgICAgICAgCSAgICAgICAgJGdyb3VwZWR7JGdyb3VwX2lkfSA9IFtAZ3Jv +dXBlZF9pdGVtc107CgkJCQl9CiAgICAgICAgICAgICAgIAkJfQoJCX0KCQllbHNlCgkJewoJCQlt +eSAkZ3JvdXBfaWQgPSAiVW5zcGVjaWZpZWQgIiAuICRtZXRhZmllbGQtPm5hbWU7CiAgCSAgICAJ +CWlmKCBleGlzdHMgJGdyb3VwZWR7JGdyb3VwX2lkfSApICN3ZSd2ZSBhbHJlYWR5IHNldCB0aGlz +IGxpc3QgdXAsIHB1c2ggYSBuZXcgaXRlbSBvbiB0byB0aGUgbGlzdAoJCSAgCXsKCQkJCWlmKCAk +aWRzX29ubHkgKSAjc29tZXRpbWVzIHdlIG9ubHkgd2FudCBpZHMgcmF0aGVyIHRoYW4gdGhlIHdo +b2xlIGl0ZW0KCQkJCXsKCQkJCQlwdXNoIEB7JGdyb3VwZWR7JGdyb3VwX2lkfX0sICRpdGVtLT5p +ZDsKCQkJCX0KCQkJCWVsc2UKCQkJCXsKCQkJCQlwdXNoIEB7JGdyb3VwZWR7JGdyb3VwX2lkfX0s +ICRpdGVtOwoJCQkJfQoJICAgICAgIAkJfQogICAgICAgIAkgICAgICAJZWxzZSAjc2V0IHVwIGEg +bGlzdCBmb3IgdGhpcyBncm91cAoJICAgICAgICAJewoJCQkJbXkgQGdyb3VwZWRfaXRlbXM7CgkJ +CQlpZiggJGlkc19vbmx5ICkgI3NvbWV0aW1lcyB3ZSBvbmx5IHdhbnQgaWRzIHJhdGhlciB0aGFu +IHRoZSB3aG9sZSBpdGVtCgkJICAgICAgICAgICAgICAgIHsJCiAgICAgICAgCQkJCUBncm91cGVk +X2l0ZW1zID0gKCRpdGVtLT5pZCk7CiAgICAgICAgICAgICAgICAJCX0KCSAgICAgICAgICAgICAg +ICAJZWxzZQogICAgICAgIAkgICAgICAgICAgICAgICAgewoJICAgICAgICAgICAgICAgCSAgICAg +ICAgICAgICAgICBAZ3JvdXBlZF9pdGVtcyA9ICgkaXRlbSk7CiAgICAgICAgCSAgICAgICAgICAg +ICAgIAl9CgkgICAgICAgICAgICAgIAkgICAgICAgICRncm91cGVkeyRncm91cF9pZH0gPSBbQGdy +b3VwZWRfaXRlbXNdOwoJCQl9CgkJfQogICAgICAgCX0gKTsKCgkjbm93IHNvcnQgdGhlIGdyb3Vw +cyBhbmQgYWRkIGh1bWFuIHJlYWRhYmxlIGxhYmVscwoJbXkgQHNvcnRlZF9ncm91cHM7CgkKCW15 +ICRyZXZlcnNlID0gMDsKCSRyZXZlcnNlID0gJHNlbGYtPntwcm9jZXNzb3J9LT57Z3JvdXBfb3B0 +c30tPntyZXZlcnNlX29yZGVyfSBpZiBleGlzdHMgJHNlbGYtPntwcm9jZXNzb3J9LT57Z3JvdXBf +b3B0c30tPntyZXZlcnNlX29yZGVyfTsKCWlmKCAkbWV0YWZpZWxkLT50eXBlIGVxICJuYW1lZHNl +dCIgKQoJewoJCW15KCAkdGFncywgJGxhYmVscyApID0gJG1ldGFmaWVsZC0+dGFnc19hbmRfbGFi +ZWxzKCAkc2Vzc2lvbiApOwoJCSNjb252ZXJ0IHRhZ3MgdG8gYSBoYXNoIG9mIHZhbHVlcyBhbmQg +YSBwcmlvcml0eSAoZm9yIG9yZGVyaW5nKQoJCW15ICVwcmlvcml0eTsKCQlteSAkaW5kZXggPSAx +OwoJCWZvcmVhY2ggbXkgJHRhZyAoQHskdGFnc30gKQoJCXsKCQkJJHByaW9yaXR5eyR0YWd9ID0g +JGluZGV4OwoJCQkkaW5kZXgrKzsKCQl9CgkJZm9yZWFjaCBteSAka2V5IChzb3J0IHskcHJpb3Jp +dHl7JGF9IDw9PiAkcHJpb3JpdHl7JGJ9fSBrZXlzICVncm91cGVkKQogICAgICAgIAl7CgkJCXB1 +c2ggQHNvcnRlZF9ncm91cHMsICRzZWxmLT5fbWFrZV9ncm91cGVkX2l0ZW0oICRncm91cGVkeyRr +ZXl9LCAkbGFiZWxzLT57JGtleX0gKTsKCQl9Cgl9CgllbHNpZiggJG1ldGFmaWVsZC0+dHlwZSBl +cSAic3ViamVjdCIgKQoJewkJCgkJbXkgJGRzID0gJHNlc3Npb24tPmRhdGFzZXQoICJzdWJqZWN0 +IiApOwoJCW15IEB2YWx1ZXMgPSBrZXlzICVncm91cGVkOwoJCW15ICRzb3J0ZWQgPSAkbWV0YWZp +ZWxkLT5zb3J0X3ZhbHVlcyggJHNlc3Npb24sIFxAdmFsdWVzICk7CgkJbXkgJXByaW9yaXR5OwoJ +CW15ICRpbmRleCA9IDE7CiAgICAgICAgICAgICAgICBmb3JlYWNoIG15ICR2YWx1ZSAoQHskc29y +dGVkfSApCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAgICRwcmlvcml0 +eXskdmFsdWV9ID0gJGluZGV4OwogICAgICAgICAgICAgICAgICAgICAgICAkaW5kZXgrKzsKICAg +ICAgICAgICAgICAgIH0KCQlmb3JlYWNoIG15ICRrZXkgKHNvcnQgeyRwcmlvcml0eXskYX0gPD0+ +ICRwcmlvcml0eXskYn19IGtleXMgJWdyb3VwZWQpCiAgICAgICAgICAgICAgICB7CgkJCW15ICRz +dWJqID0gJGRzLT5kYXRhb2JqKCAka2V5ICk7CiAgICAgICAgICAgICAgICAgICAgICAgIHB1c2gg +QHNvcnRlZF9ncm91cHMsICRzZWxmLT5fbWFrZV9ncm91cGVkX2l0ZW0oICRncm91cGVkeyRrZXl9 +LCBFUHJpbnRzOjpVdGlsczo6dHJlZV90b191dGY4KCAkc3Viai0+cmVuZGVyX2Rlc2NyaXB0aW9u +ICkgKSBpZiBkZWZpbmVkICRzdWJqOwogICAgICAgICAgICAgICAgfQoJfQoJZWxzaWYoICRtZXRh +ZmllbGQtPnR5cGUgZXEgImRhdGUiICkKCXsKCQlpZiggJHJldmVyc2UgKQoJCXsKCQkJZm9yZWFj +aCBteSAka2V5ICggc29ydCB7JGIgPD0+ICRhfSBrZXlzICVncm91cGVkICkKCQkJewoJCQkJcHVz +aCBAc29ydGVkX2dyb3VwcywgJHNlbGYtPl9tYWtlX2dyb3VwZWRfaXRlbSggJGdyb3VwZWR7JGtl +eX0sICRrZXkgKTsKCQkJfQoJCX0KCQllbHNlCgkJewoJCQlmb3JlYWNoIG15ICRrZXkgKCBzb3J0 +IHskYSA8PT4gJGJ9IGtleXMgJWdyb3VwZWQgKQoJCQl7CgkJCQlwdXNoIEBzb3J0ZWRfZ3JvdXBz +LCAkc2VsZi0+X21ha2VfZ3JvdXBlZF9pdGVtKCAkZ3JvdXBlZHska2V5fSwgJGtleSApOwoJCQl9 +CgkJfQoJfQoJZWxzZQoJewkKCQlpZiggJHJldmVyc2UgKQoJCXsKCQkJZm9yZWFjaCBteSAka2V5 +ICggc29ydCB7JGIgY21wICRhfSBrZXlzICVncm91cGVkICkKCQkJewoJCQkJcHVzaCBAc29ydGVk +X2dyb3VwcywgJHNlbGYtPl9tYWtlX2dyb3VwZWRfaXRlbSggJGdyb3VwZWR7JGtleX0sICRrZXkg +KTsKCQkJfQoJCX0KCQllbHNlCgkJewoJCQlmb3JlYWNoIG15ICRrZXkgKCBzb3J0IGtleXMgJWdy b3VwZWQgKQoJCQl7CgkJCQlwdXNoIEBzb3J0ZWRfZ3JvdXBzLCAkc2VsZi0+X21ha2VfZ3JvdXBl -ZF9pdGVtKCAkZ3JvdXBlZHska2V5fSwgJGtleSApOwoJCQl9CgkJfQoJCWVsc2UKCQl7CgkJCWZv -cmVhY2ggbXkgJGtleSAoIHNvcnQga2V5cyAlZ3JvdXBlZCApCgkJCXsKCQkJCXB1c2ggQHNvcnRl -ZF9ncm91cHMsICRzZWxmLT5fbWFrZV9ncm91cGVkX2l0ZW0oICRncm91cGVkeyRrZXl9LCAka2V5 -ICk7CgkJCX0KCQl9Cgl9CgoJI2NoZWNrIGZvciBhbnkgdW5zcGVjaWZpZWQgZ3JvdXBzCglteSAk -Z3JvdXBfaWQgPSAiVW5zcGVjaWZpZWQgIiAuICRtZXRhZmllbGQtPm5hbWU7CglpZiggZXhpc3Rz -ICRncm91cGVkeyRncm91cF9pZH0gKQoJewoJCXB1c2ggQHNvcnRlZF9ncm91cHMsICRzZWxmLT5f -bWFrZV9ncm91cGVkX2l0ZW0oICRncm91cGVkeyRncm91cF9pZH0sICRncm91cF9pZCApOwoJfQoK -CXJldHVybiBcQHNvcnRlZF9ncm91cHM7Cn0JCgoKc3ViIF9tYWtlX2dyb3VwZWRfaXRlbQp7Cglt -eSggJHNlbGYsICRsaXN0LCAkbGFiZWwgKSA9IEBfOwoJbXkgJWdyb3VwOwoJJGdyb3Vwe2xpc3R9 -ID0gJGxpc3Q7CgkkZ3JvdXB7bGFiZWx9ID0gJGxhYmVsOwoJcmV0dXJuIFwlZ3JvdXA7Cn0KCnN1 -YiByZW5kZXJfc2VsZWN0YWxsCnsKCW15KCAkc2VsZiwgJHhtbCApID0gQF87CgoJbXkgJHRvZ2ds -ZV9mdW5jdGlvbiA9ICcKCQl2YXIgaXNDaGVja2VkID0gdHJ1ZTsKCQlmdW5jdGlvbiB0b2dnbGVD -aGVja2JveGVzKCkgewoJICAgICAgICAJdmFyIGV4cG9ydF9vcHRpb25zID0gZG9jdW1lbnQuZ2V0 -RWxlbWVudHNCeUNsYXNzTmFtZSgicmVwb3J0X2V4cG9ydF9vcHRpb25zIik7CgkJCWZvciggZXhw -b3J0X29wdGlvbiBvZiBleHBvcnRfb3B0aW9ucyApCgkJCXsKCQkJCXZhciBjaGVja2JveGVzID0g -ZXhwb3J0X29wdGlvbi5nZXRFbGVtZW50c0J5VGFnTmFtZSggImlucHV0IiApCgkJCQlmb3IoIGNo -ZWNrYm94IG9mIGNoZWNrYm94ZXMgKQoJCQkJewoJCQkJCWlmKGlzQ2hlY2tlZCkKCQkJCQl7Cgkg -ICAgICAgICAgICAgICAgCQkJY2hlY2tib3guY2hlY2tlZCA9ICIiOwoJCSAgCSAgICAgICAgCX0K -CQkJCQllbHNlCgkJCQkJewoJCQkJICAgICAgICAgICAgICAgIGNoZWNrYm94LmNoZWNrZWQgPSAi -Y2hlY2tlZCI7CgkJCQkJfQoJICAgICAgICAgCQl9CgkJCX0KCQkJaXNDaGVja2VkID0gIWlzQ2hl -Y2tlZDsKCQl9JzsKCQoJbXkgJGpzX3RhZyA9ICR4bWwtPmNyZWF0ZV9lbGVtZW50KCAic2NyaXB0 -IiApOwoJJGpzX3RhZy0+YXBwZW5kQ2hpbGQoICR4bWwtPmNyZWF0ZV90ZXh0X25vZGUoICR0b2dn -bGVfZnVuY3Rpb24gKSApOwoJcmV0dXJuICRqc190YWc7Cn0KCnN1YiByZW5kZXJfY2xlYXJmb3Jt -CnsKCW15KCAkc2VsZiwgJHhtbCApID0gQF87CgoJbXkgJGNsZWFyX2Z1bmN0aW9uID0gJwoJCWZ1 -bmN0aW9uIGNsZWFyRm9ybSgpewoJCQl2YXIgcmVwb3J0ID0gZG9jdW1lbnQuZ2V0RWxlbWVudEJ5 -SWQoICJjdXN0b21fcmVwb3J0IiApOwoJCQl2YXIgZm9ybSA9IHJlcG9ydC5nZXRFbGVtZW50c0J5 -Q2xhc3NOYW1lKCJzZWxlY3RlZF9mb3JtIilbMF07CgkJCXZhciBpbnB1dHMgPSBmb3JtLmdldEVs -ZW1lbnRzQnlUYWdOYW1lKCAiaW5wdXQiICk7CgkJCWZvciggaW5wdXQgb2YgaW5wdXRzICkKCQkJ -ewoJCQkJZmllbGRfdHlwZSA9IGlucHV0LnR5cGUudG9Mb3dlckNhc2UoKTsJCgkJCQlzd2l0Y2gg -KGZpZWxkX3R5cGUpCgkJCQl7CgkJCQljYXNlICJ0ZXh0IjoKCQkJCWNhc2UgInRleHRhcmVhIjoK -CQkJCQlpbnB1dC52YWx1ZSA9ICIiOwoJCQkJCWJyZWFrOwoJCQkJY2FzZSAicmFkaW8iOgoJCQkJ -Y2FzZSAiY2hlY2tib3giOgoJCQkJCWlmIChpbnB1dC5jaGVja2VkKQoJCQkJCXsKICAgICAgICAJ -CQkJCWlucHV0LmNoZWNrZWQgPSBmYWxzZTsKCQkJCQl9CgkJCQkJYnJlYWs7CgkJCQljYXNlICJz -ZWxlY3Qtb25lIjoKCQkJCWNhc2UgInNlbGVjdC1tdWx0aSI6CgkJCQkJaW5wdXQuc2VsZWN0ZWRJ -bmRleCA9IC0xOwoJCQkJCWJyZWFrOwoJCQkJZGVmYXVsdDoKCQkJCQlicmVhazsKCQkJCX0KCQkJ -fQkKCQkgICAgICAgIHZhciBzZWxlY3RzID0gZm9ybS5nZXRFbGVtZW50c0J5VGFnTmFtZSggInNl -bGVjdCIgKTsKCQkJZm9yKCBzZWxlY3Qgb2Ygc2VsZWN0cyApCgkJCXsJCgkJCQlpZiggc2VsZWN0 -Lmhhc0F0dHJpYnV0ZSgibXVsdGlwbGUiKSApCgkJCQl7CgkJCQkJc2VsZWN0LnNlbGVjdGVkSW5k -ZXggPSAtMTsKCQkJCX0KCQkJfQkJCgoJCX0nOwkJCgoJbXkgJGpzX3RhZyA9ICR4bWwtPmNyZWF0 -ZV9lbGVtZW50KCAic2NyaXB0IiApOwogICAgICAgICRqc190YWctPmFwcGVuZENoaWxkKCAkeG1s -LT5jcmVhdGVfdGV4dF9ub2RlKCAkY2xlYXJfZnVuY3Rpb24gKSApOwogICAgICAgIHJldHVybiAk -anNfdGFnOwp9CgoxOwo= +ZF9pdGVtKCAkZ3JvdXBlZHska2V5fSwgJGtleSApOwoJCQl9CgkJfQoJfQoKCSNjaGVjayBmb3Ig +YW55IHVuc3BlY2lmaWVkIGdyb3VwcwoJbXkgJGdyb3VwX2lkID0gIlVuc3BlY2lmaWVkICIgLiAk +bWV0YWZpZWxkLT5uYW1lOwoJaWYoIGV4aXN0cyAkZ3JvdXBlZHskZ3JvdXBfaWR9ICkKCXsKCQlw +dXNoIEBzb3J0ZWRfZ3JvdXBzLCAkc2VsZi0+X21ha2VfZ3JvdXBlZF9pdGVtKCAkZ3JvdXBlZHsk +Z3JvdXBfaWR9LCAkZ3JvdXBfaWQgKTsKCX0KCglyZXR1cm4gXEBzb3J0ZWRfZ3JvdXBzOwp9CQoK +CnN1YiBfbWFrZV9ncm91cGVkX2l0ZW0KewoJbXkoICRzZWxmLCAkbGlzdCwgJGxhYmVsICkgPSBA +XzsKCW15ICVncm91cDsKCSRncm91cHtsaXN0fSA9ICRsaXN0OwoJJGdyb3Vwe2xhYmVsfSA9ICRs +YWJlbDsKCXJldHVybiBcJWdyb3VwOwp9CgpzdWIgcmVuZGVyX3NlbGVjdGFsbAp7CglteSggJHNl +bGYsICR4bWwgKSA9IEBfOwoKCW15ICR0b2dnbGVfZnVuY3Rpb24gPSAnCgkJdmFyIGlzQ2hlY2tl +ZCA9IHRydWU7CgkJZnVuY3Rpb24gdG9nZ2xlQ2hlY2tib3hlcygpIHsKCSAgICAgICAgCXZhciBl +eHBvcnRfb3B0aW9ucyA9IGRvY3VtZW50LmdldEVsZW1lbnRzQnlDbGFzc05hbWUoInJlcG9ydF9l +eHBvcnRfb3B0aW9ucyIpOwoJCQlmb3IoIGV4cG9ydF9vcHRpb24gb2YgZXhwb3J0X29wdGlvbnMg +KQoJCQl7CgkJCQl2YXIgY2hlY2tib3hlcyA9IGV4cG9ydF9vcHRpb24uZ2V0RWxlbWVudHNCeVRh +Z05hbWUoICJpbnB1dCIgKQoJCQkJZm9yKCBjaGVja2JveCBvZiBjaGVja2JveGVzICkKCQkJCXsK +CQkJCQlpZihpc0NoZWNrZWQpCgkJCQkJewoJICAgICAgICAgICAgICAgIAkJCWNoZWNrYm94LmNo +ZWNrZWQgPSAiIjsKCQkgIAkgICAgICAgIAl9CgkJCQkJZWxzZQoJCQkJCXsKCQkJCSAgICAgICAg +ICAgICAgICBjaGVja2JveC5jaGVja2VkID0gImNoZWNrZWQiOwoJCQkJCX0KCSAgICAgICAgIAkJ +fQoJCQl9CgkJCWlzQ2hlY2tlZCA9ICFpc0NoZWNrZWQ7CgkJfSc7CgkKCW15ICRqc190YWcgPSAk +eG1sLT5jcmVhdGVfZWxlbWVudCggInNjcmlwdCIgKTsKCSRqc190YWctPmFwcGVuZENoaWxkKCAk +eG1sLT5jcmVhdGVfdGV4dF9ub2RlKCAkdG9nZ2xlX2Z1bmN0aW9uICkgKTsKCXJldHVybiAkanNf +dGFnOwp9CgpzdWIgcmVuZGVyX2NsZWFyZm9ybQp7CglteSggJHNlbGYsICR4bWwgKSA9IEBfOwoK +CW15ICRjbGVhcl9mdW5jdGlvbiA9ICcKCQlmdW5jdGlvbiBjbGVhckZvcm0oKXsKCQkJdmFyIHJl +cG9ydCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCAiY3VzdG9tX3JlcG9ydCIgKTsKCQkJdmFy +IGZvcm0gPSByZXBvcnQuZ2V0RWxlbWVudHNCeUNsYXNzTmFtZSgic2VsZWN0ZWRfZm9ybSIpWzBd +OwoJCQl2YXIgaW5wdXRzID0gZm9ybS5nZXRFbGVtZW50c0J5VGFnTmFtZSggImlucHV0IiApOwoJ +CQlmb3IoIGlucHV0IG9mIGlucHV0cyApCgkJCXsKCQkJCWZpZWxkX3R5cGUgPSBpbnB1dC50eXBl +LnRvTG93ZXJDYXNlKCk7CQoJCQkJc3dpdGNoIChmaWVsZF90eXBlKQoJCQkJewoJCQkJY2FzZSAi +dGV4dCI6CgkJCQljYXNlICJ0ZXh0YXJlYSI6CgkJCQkJaW5wdXQudmFsdWUgPSAiIjsKCQkJCQli +cmVhazsKCQkJCWNhc2UgInJhZGlvIjoKCQkJCWNhc2UgImNoZWNrYm94IjoKCQkJCQlpZiAoaW5w +dXQuY2hlY2tlZCkKCQkJCQl7CiAgICAgICAgCQkJCQlpbnB1dC5jaGVja2VkID0gZmFsc2U7CgkJ +CQkJfQoJCQkJCWJyZWFrOwoJCQkJY2FzZSAic2VsZWN0LW9uZSI6CgkJCQljYXNlICJzZWxlY3Qt +bXVsdGkiOgoJCQkJCWlucHV0LnNlbGVjdGVkSW5kZXggPSAtMTsKCQkJCQlicmVhazsKCQkJCWRl +ZmF1bHQ6CgkJCQkJYnJlYWs7CgkJCQl9CgkJCX0JCgkJICAgICAgICB2YXIgc2VsZWN0cyA9IGZv +cm0uZ2V0RWxlbWVudHNCeVRhZ05hbWUoICJzZWxlY3QiICk7CgkJCWZvciggc2VsZWN0IG9mIHNl +bGVjdHMgKQoJCQl7CQoJCQkJaWYoIHNlbGVjdC5oYXNBdHRyaWJ1dGUoIm11bHRpcGxlIikgKQoJ +CQkJewoJCQkJCXNlbGVjdC5zZWxlY3RlZEluZGV4ID0gLTE7CgkJCQl9CgkJCX0JCQoKCQl9JzsJ +CQoKCW15ICRqc190YWcgPSAkeG1sLT5jcmVhdGVfZWxlbWVudCggInNjcmlwdCIgKTsKICAgICAg +ICAkanNfdGFnLT5hcHBlbmRDaGlsZCggJHhtbC0+Y3JlYXRlX3RleHRfbm9kZSggJGNsZWFyX2Z1 +bmN0aW9uICkgKTsKICAgICAgICByZXR1cm4gJGpzX3RhZzsKfQoKMTsK + document plugins/EPrints/Plugin/Screen/Report/EPrint.pm text/plain d3e587ba8d8f55c66102969ef662e3cb @@ -1589,6 +1710,7 @@ cmV0dXJuIEBidWxsZXRzOwp9CgoxOwo= + document plugins/EPrints/Plugin/Screen/Report/Example.pm text/plain 1c2d8c6ae6fc484e6bb1a93978ec88b9 @@ -1631,6 +1753,7 @@ ZWN0czsKfQoKMTsK + document plugins/EPrints/Plugin/Screen/Report/Example/Articles.pm text/plain 4c43aa504919a5484599af05f9b146b1 @@ -1648,6 +1771,7 @@ ID0+ICdhcnRpY2xlJyB9OwoKCXJldHVybiBcQGZpbHRlcnM7Cn0KCjE7Cg== + document plugins/EPrints/Plugin/Screen/Report/Example/ConferenceItems.pm text/plain 3c8b240f6728e37d91784edf2409a85c @@ -1666,6 +1790,7 @@ MTsK + document plugins/EPrints/Plugin/Screen/Report/User.pm text/plain cf71f006233ea48a6206f5e186956798 @@ -1707,6 +1832,7 @@ ICAgIG15IEBidWxsZXRzOwoKICAgICAgICByZXR1cm4gQGJ1bGxldHM7Cn0KCjE7Cg== + document static/images/epm/reports.png image/png 11fe836e11dc3075b829e17f64caf50d @@ -2145,11 +2271,12 @@ mCeqVAAAAABJRU5ErkJggg== + document static/javascript/auto/reports.js text/plain - 46e3bc42410200895fcfe29085a1246e + 058ab00d3be58f69cb6f9f3e6d7625f9 MD5 - 12510 + 16024 dmFyIGluaXRSZXBvcnRGb3JtID0gZnVuY3Rpb24oKXsKCiAgICAgICAgLy9wb2x5ZmlsbCBmb3Ig SUUKICAgICAgICAoZnVuY3Rpb24gKCkgewogICAgICAgICAgICAgICAgaWYgKCB0eXBlb2Ygd2lu ZG93LkN1c3RvbUV2ZW50ID09PSAiZnVuY3Rpb24iICkgcmV0dXJuIGZhbHNlOyAvL0lmIG5vdCBJ @@ -2167,217 +2294,280 @@ ICAgICAgICBzZWxlY3QuYWRkRXZlbnRMaXN0ZW5lcignY2hhbmdlJywgb25Gb3JtU2VsZWN0KTsK CiAgICAgICAgZG9jdW1lbnQub2JzZXJ2ZSgiZG9tOmxvYWRlZCIsIGZ1bmN0aW9uKCkgewogICAg ICAgICAgICAgICAgdmFyIGNoYW5nZVNlbGVjdCA9IG5ldyBDdXN0b21FdmVudCgiY2hhbmdlIik7 CiAgICAgICAgICAgICAgICBzZWxlY3QuZGlzcGF0Y2hFdmVudChjaGFuZ2VTZWxlY3QpOwogICAg -ICAgIH0pOwp9OwoKCnZhciBvbkZvcm1TZWxlY3QgPSBmdW5jdGlvbigpewoJLy9nZXQgZm9ybSBp -ZAoJdmFyIGZvcm1pZCA9IHRoaXMub3B0aW9uc1t0aGlzLnNlbGVjdGVkSW5kZXhdLmdldEF0dHJp -YnV0ZSgnZm9ybScpOwoJCgkvL2hpZGUgb3RoZXIgZm9ybXMKCSQkKCcuZXBfc2VhcmNoX2ZpZWxk -cycpLmVhY2goZnVuY3Rpb24gKGVsZW0pIAoJewkKCQkvL2hpZGUgdGhlIGZvcm0KCQkkKGVsZW0p -LmhpZGUoKTsKCQkkKGVsZW0pLnJlbW92ZUNsYXNzTmFtZSgic2VsZWN0ZWRfZm9ybSIpOwoJCSQo -ZWxlbSkuc2VsZWN0KCdpbnB1dCcpLmVhY2goZnVuY3Rpb24gKGlucHV0KQoJCXsKCQkJJChpbnB1 -dCkuc2V0QXR0cmlidXRlKCJkaXNhYmxlZCIsICJkaXNhYmxlZCIpOwoJCX0pOwoJCSQoZWxlbSku -c2VsZWN0KCdzZWxlY3QnKS5lYWNoKGZ1bmN0aW9uIChzZWxlY3QpCiAgICAgICAgewogICAgICAg -ICAgICAkKHNlbGVjdCkuc2V0QXR0cmlidXRlKCJkaXNhYmxlZCIsICJkaXNhYmxlZCIpOwogICAg -ICAgIH0pOwoJfSk7CgkJCgkvL3Nob3cgdGhlIGZvcm0gd2Ugd2FudAoJJChmb3JtaWQpLnNob3co -KTsKCSQoZm9ybWlkKS5hZGRDbGFzc05hbWUoInNlbGVjdGVkX2Zvcm0iKTsKCgkvL2VuYWJsZSB0 -aGlzIGZvcm0ncyBpbnB1dCBlbGVtZW50cwoJJChmb3JtaWQpLnNlbGVjdCgnaW5wdXQnKS5lYWNo -KGZ1bmN0aW9uIChpbnB1dCkKCXsKCQkkKGlucHV0KS5yZW1vdmVBdHRyaWJ1dGUoImRpc2FibGVk -Iik7Cgl9KTsKCS8vZW5hYmxlIHRoaXMgZm9ybSdzIHNlbGVjdCBlbGVtZW50cwoJJChmb3JtaWQp -LnNlbGVjdCgnc2VsZWN0JykuZWFjaChmdW5jdGlvbiAoc2VsZWN0KQogICAgewogICAgICAgICQo -c2VsZWN0KS5yZW1vdmVBdHRyaWJ1dGUoImRpc2FibGVkIik7CiAgICB9KTsKCn07CgovLyBVc2Vk -IGJ5IHRoZSBTY3JlZW46OlJlcG9ydDo6cmVuZGVyIG1ldGhvZAoKdmFyIEVQcmludHNfU2NyZWVu -X1JlcG9ydF9Mb2FkZXIgPSBDbGFzcy5jcmVhdGUoewoJaGFzX3Byb2JsZW1zOiAwLAoJY291bnQ6 -IDAsCglydW5zOiAwLAoJcHJvZ3Jlc3M6IG51bGwsCglpZHM6IEFycmF5KCksCglzdGVwOiBudWxs -LAoJbWluU3RlcDogMjAsIC8vIElmIGBzdGVwYCBpcyBzZXQgdG8gYG51bGxgIHRoZW4gdGhpcyBp -cyB0aGUgbWluaW11bSBgc3RlcGAgdmFsdWUKCXByZWZpeDogJycsCglvblByb2JsZW1zOiBmdW5j -dGlvbigpIHt9LAoJb25GaW5pc2g6IGZ1bmN0aW9uKCkge30sCgl1cmw6ICIiLAoJcGFyYW1ldGVy -czogIiIsCgljb250YWluZXI6IG51bGwsCglzaG93X2NvbXBsaWFuY2U6IDEsCQoKCS8vIHRvIHNo -b3cgYSBwcmV0dHkgcHJvZ3Jlc3MgYmFyICglIGNvbXBsaWFuY2UpOgoJdG90YWxfZGF0YW9ianM6 -IDAsCgl0b3RhbF9ub25jb21wbGlhbnQ6IDAsCgoKCWluaXRpYWxpemU6IGZ1bmN0aW9uKG9wdHMp -IHsKCQlpZiggb3B0cy5pZHMgKQoJCQl0aGlzLmlkcyA9IG9wdHMuaWRzOwoJCWlmKCBvcHRzLnN0 -ZXAgKQoJCQl0aGlzLnN0ZXAgPSBvcHRzLnN0ZXA7CgkJaWYoIG9wdHMubWluU3RlcCApCgkJCXRo -aXMubWluU3RlcCA9IG9wdHMubWluU3RlcDsKCQlpZiggb3B0cy5wcmVmaXggKQoJCQl0aGlzLnBy -ZWZpeCA9IG9wdHMucHJlZml4OwoJCWlmKCBvcHRzLm9uRmluaXNoICkKCQkJdGhpcy5vbkZpbmlz -aCA9IG9wdHMub25GaW5pc2g7CgkJaWYoIG9wdHMub25Qcm9ibGVtcyApCgkJCXRoaXMub25Qcm9i -bGVtcyA9IG9wdHMub25Qcm9ibGVtczsKCQlpZiggb3B0cy51cmwgKQoJCXsKCQkJdGhpcy51cmwg -PSBvcHRzLnVybDsKCQl9CgkJaWYoIG9wdHMucGFyYW1ldGVycyApCgkJCXRoaXMucGFyYW1ldGVy -cyA9IG9wdHMucGFyYW1ldGVyczsKCQlpZiggb3B0cy5jb250YWluZXJfaWQgKQoJCQl0aGlzLmNv -bnRhaW5lciA9ICQoIG9wdHMuY29udGFpbmVyX2lkICk7CS8vIHNob3VsZCBmYWlsIGlmIGNvbnRh -aW5lciBkb2Vzbid0IGV4aXN0Li4uCgkJaWYoIG9wdHMuaGFzT3duUHJvcGVydHkoJ3Nob3dfY29t -cGxpYW5jZScpICkKCQl7CgkJCXRoaXMuc2hvd19jb21wbGlhbmNlID0gb3B0cy5zaG93X2NvbXBs -aWFuY2U7CgkJfQoJCWlmKCBvcHRzLmxhYmVscyApCgkJewoJCQl0aGlzLmxhYmVscyA9IG9wdHMu -bGFiZWxzOwoJCX0KCX0sCgoJZXhlY3V0ZTogZnVuY3Rpb24oKSB7CgkJLy8gcHJvZ3Jlc3MtYmFy -CgoJCXRoaXMuY29udGFpbmVyLmluc2VydCggbmV3IEVsZW1lbnQoICdkaXYnLCB7ICdjbGFzcyc6 -ICdlcF9yZXBvcnRfcHJvZ3Jlc3NfYmFyJywgJ2lkJzogdGhpcy5wcmVmaXggKyAiX3Byb2dyZXNz -X2JhciIgfSApICk7CQoKCQl0aGlzLmN1cnJlbnRfZ3JvdXBpbmcgPSBudWxsOwkvLyBtaWdodCBu -b3QgYmUgc2V0IGluIHRoZSByZXR1cm5lZCB2YWx1ZSBidXQgdGhhdCdzIGFsbG93ZWQvT0sKCgkJ -dGhpcy5kYXRhb2JqcyA9IHt9OwoJCXZhciBncm91cGVkID0gZmFsc2U7CgkJdmFyIHNlZW5faWRz -ID0ge307CgkJdGhpcy5ub19pdGVtcyA9IHRoaXMuaWRzLmxlbmd0aDsKCQl0aGlzLnJldHJpZXZl -ZCA9IFtdOwoKCQkvLyBVbmxlc3MgYHN0ZXBgIGlzIHNldCB0aGlzIHdpbGwgYXV0b21hdGljYWxs -eSBjYWxjdWxhdGUgaXQgZGVwZW5kaW5nCgkJLy8gb24gdGhlIG51bWJlciBvZiBpdGVtcyBpbiB0 -aGUgbGlzdC4KCQkvLyBUaGlzIGFsbG93cyB0aGUgc3RlcHMgdG8gc2NhbGUgd2l0aCBsYXJnZXIg -cXVlcmllcyAoYWltaW5nIGZvciAxMDAKCQkvLyBBSkFYIHJlcXVlc3RzKSBzbyB0aGF0IGl0IGRv -ZXNuJ3QgY2F1c2UgU2VydmVyIEVycm9ycy4KCQlpZiAodGhpcy5zdGVwID09PSBudWxsKSB7CgkJ -CXRoaXMuc3RlcCA9IE1hdGgubWF4KE1hdGgucm91bmQodGhpcy5ub19pdGVtcyAvIDEwMCksIHRo -aXMubWluU3RlcCk7CgkJfQoKCQlpZiggIWlzSW50ZWdlcih0aGlzLmlkc1swXSkgKSAvL2lkcyBo -YXZlIGJlZW4gZ3JvdXBlZAoJCXsJCgkJCWdyb3VwZWQgPSB0cnVlOwoJCQl0aGlzLmdyb3VwZWRf -aWRzID0gdGhpcy5pZHM7CgkJCXRoaXMuaWRzID0gW107CgkJCWZvciggdmFyIGkgPSAwOyBpIDwg -dGhpcy5ncm91cGVkX2lkcy5sZW5ndGg7IGkrKyApCgkJCXsKCQkJCXRoaXMuaWRzID0gdGhpcy5p -ZHMuY29uY2F0KHRoaXMuZ3JvdXBlZF9pZHNbaV0ubGlzdCk7CgkJCX0KCQkJLy90aGUgZ3JvdXBp -bmcgbWF5IGhhdmUgY3JlYXRlZCBkdXBsaWNhdGUgcmVjb3JkcyAoaS5lLiBhIHJlY29yZCBjYW4g -YXBwZWFyIGluIG1vcmUgdGhhbiBvbmUgZ3JvdXApIC0gaXQncyBoYW5keSB0byBoYXZlIGFuIGFy -cmF5IG9mIGFsbCB0aGUgdW5pcXVlIHJlY29yZHMKCQkJdGhpcy51bmlxdWUgPSB0aGlzLmlkcy5m -aWx0ZXIoZnVuY3Rpb24oaXRlbSwgaSwgYXIpeyByZXR1cm4gYXIuaW5kZXhPZihpdGVtKSA9PT0g -aTsgfSk7CgkJCXRoaXMubm9faXRlbXMgPSB0aGlzLnVuaXF1ZS5sZW5ndGg7CgkJfQoJCWZvcih2 -YXIgaSA9IDA7IGkgPCB0aGlzLmlkcy5sZW5ndGg7IGkrPXRoaXMuc3RlcCkKCQl7CgkJCS8vIGFy -Z3VtZW50cyBmb3IgQWpheCBxdWVyeSBBTkQgY3JlYXRlcyB0aGUgSFRNTCBwbGFjZWhvbGRlcnMg -PGRpdj4ncyAodGhhdCB3aWxsIHJlY2VpdmUgdGhlIGNvbnRlbnQgb2YgdGhlIEFqYXggcXVlcnku -Li4pCQkJCQoJCQl2YXIgYXJncyA9ICcmYWpheD0nK3RoaXMucHJlZml4OwoJCQlmb3IodmFyIGog -PSAwOyBqIDwgdGhpcy5zdGVwICYmIGkraiA8IHRoaXMuaWRzLmxlbmd0aDsgaisrKQoJCQl7CgkJ -CQlhcmdzICs9ICcmJyArIHRoaXMucHJlZml4ICsgJz0nICsgdGhpcy5pZHNbaStqXTsKCQkJCXZh -ciBpZCA9IHRoaXMucHJlZml4ICsgJ18nICsgdGhpcy5pZHNbaStqXTsKCQkJCXZhciB0YXJnZXRf -ZWwgPSAkKCBpZCApOwoJCQkJaWYoIHRhcmdldF9lbCAhPSBudWxsICkKCQkJCXsKCQkJCQkvL3N0 -b3JlIGEgcmVjb3JkIG9mIHRoaXMgaW4gc2Vlbl9pZHMgdG8gZW5zdXJlIGVhY2ggcGxhY2Vob2xk -ZXIgaGFzIGEgdW5pcXVlIGlkCgkJCQkJaWYoICEoaWQgaW4gc2Vlbl9pZHMpICkKCQkJCQl7CgkJ -CQkJCXNlZW5faWRzW2lkXSA9IDE7CgkJCQkJfQoJCQkJCWVsc2UKCQkJCQl7CgkJCQkJCXNlZW5f -aWRzW2lkXSA9IHNlZW5faWRzW2lkXSArIDE7CgkJCQkJfQoJCQkJCWlkID0gaWQgKyAiXyIgKyBz -ZWVuX2lkc1tpZF07CgkJCQl9CgkJCQkJCgkJCQl0aGlzLmNvbnRhaW5lci5pbnNlcnQoIG5ldyBF -bGVtZW50KCAnZGl2JywgeyAnY2xhc3MnOiAnZXBfcmVwb3J0X3JvdycsICdpZCc6IGlkLCAncG9z -aXRpb24nOiBpK2ogfSApLCB7ICdwb3NpdGlvbic6ICdhZnRlcicgfSApOwoJCQl9CgoJCQltYWtl -UmVxdWVzdCh0aGlzLCBhcmdzLCBncm91cGVkKTsKCQl9CgkJaWYoIHRoaXMuaWRzID09IG51bGwg -fHwgdGhpcy5pZHMubGVuZ3RoID09IDAgKQoJCXsKCQkJdmFyIHBOb2RlID0gJCh0aGlzLnByZWZp -eCArICdfcHJvZ3Jlc3NfYmFyJykucGFyZW50Tm9kZTsKCQkJJCh0aGlzLnByZWZpeCArICdfcHJv -Z3Jlc3NfYmFyJykuaGlkZSgpOwoJCQl2YXIgc3BhbiA9IG5ldyBFbGVtZW50KCAnc3BhbicsIHsg -J2NsYXNzJzogJ2VwX3JlZl9yZXBvcnRfZW1wdHknIH0gKTsKCQkJc3Bhbi51cGRhdGUoICdSZXBv -cnQgZW1wdHknICk7CgkJCXBOb2RlLmluc2VydCggc3BhbiApOwoJCX0KCX0KfSk7CgpmdW5jdGlv -biBtYWtlUmVxdWVzdChsb2FkZXIsIGFyZ3MsIGdyb3VwZWQpIHsKCW5ldyBBamF4LlJlcXVlc3Qo -IGxvYWRlci51cmwsIHsKCQltZXRob2Q6ICdnZXQnLAoJCXBhcmFtZXRlcnM6IGxvYWRlci5wYXJh -bWV0ZXJzICsgYXJncywKCQlvbkZhaWx1cmU6ICgpID0+IHsKCQkJLy8gUmV0cnkgYWZ0ZXIgMTAw -bXMgaWYgdGhlIHF1ZXJ5IGZhaWxzIChzdWNoIGFzIHRvIGFuIEludGVybmFsCgkJCS8vIFNlcnZl -ciBFcnJvcikuCgkJCXNldFRpbWVvdXQoKCkgPT4gewoJCQkJbWFrZVJlcXVlc3QobG9hZGVyLCBh -cmdzLCBncm91cGVkKTsKCQkJfSwgMTAwKTsKCQl9LAoJCW9uU3VjY2VzczogKGZ1bmN0aW9uKHRy -YW5zcG9ydCkgewoKCQkJdmFyIGpzb24gPSB0cmFuc3BvcnQucmVzcG9uc2VUZXh0LmV2YWxKU09O -KCk7CgkJCXZhciBkYXRhID0ganNvbi5kYXRhOwoKCQkJaWYoIGRhdGEgPT0gbnVsbCApCgkJCQlk -YXRhID0gbmV3IEFycmF5KCk7CgkJCWZvciggdmFyIGk9MDsgaTxkYXRhLmxlbmd0aDsgaSsrICkK -CQkJewoJCQkJdmFyIGVudHJ5ID0gZGF0YVtpXTsKCgkJCQkvLyBlbnRyeS5kYXRhb2JqaWQKCQkJ -CS8vIGVudHJ5LnN1bW1hcnkKCQkJCS8vIGVudHJ5Lmdyb3VwaW5nCgkJCQkvLyBlbnRyeS5wcm9i -bGVtcwoKCQkJCWlmKCBlbnRyeSA9PSBudWxsICkKCQkJCQljb250aW51ZTsKCgkJCQl2YXIgZGF0 -YW9iamlkID0gZW50cnkuZGF0YW9iamlkOwoJCQkJaWYoIGRhdGFvYmppZCA9PSBudWxsICkKCQkJ -CQljb250aW51ZTsKCQkJCWlmKCAhKGRhdGFvYmppZCBpbiB0aGlzLmRhdGFvYmpzKSApCgkJCQl7 -CgkJCQkJdGhpcy5jb3VudCsrOwoJCQkJCXRoaXMuZGF0YW9ianNbZGF0YW9iamlkXSA9IGVudHJ5 -OwoJCQkJfQoJCQl9CgoJCQkvLyB3ZSd2ZSByZXRyaWV2ZWQgYWxsIHRoZSByZWNvcmRzCgkJCWlm -KCB0aGlzLmNvdW50ID09IHRoaXMubm9faXRlbXMgKQoJCQl7CgkJCQkkKCB0aGlzLnByZWZpeCAr -ICdfcHJvZ3Jlc3NfYmFyJyApLnJlbW92ZSgpOwoJCQkJaWYoIHRoaXMuaGFzX3Byb2JsZW1zICkK -CQkJCQl0aGlzLm9uUHJvYmxlbXModGhpcyk7CgkJCQl0aGlzLm9uRmluaXNoKHRoaXMpOwoKCQkJ -CS8vYWRkIHRoZSBncm91cCBoZWFkaW5ncwoJCQkJaWYoZ3JvdXBlZCkKCQkJCXsKCQkJCQl2YXIg -cG9zaXRpb24gPSAwOwoJCQkJCWZvciggdmFyIGkgPSAwOyBpIDwgdGhpcy5ncm91cGVkX2lkcy5s -ZW5ndGg7IGkrKyApCgkJCQkJewoJCQkJCQl2YXIgdGFyZ2V0X2VsID0gZG9jdW1lbnQucXVlcnlT -ZWxlY3RvckFsbCgnW3Bvc2l0aW9uPSInICsgcG9zaXRpb24gKyAnIl0nKVswXTsKCQkJCQkJcG9z -aXRpb24gPSBwb3NpdGlvbiArIHRoaXMuZ3JvdXBlZF9pZHNbaV0ubGlzdC5sZW5ndGg7CgkJCQkJ -CXZhciBncm91cGluZ19jb250YWluZXIgPSBuZXcgRWxlbWVudCggJ2RpdicsIHsgJ2NsYXNzJzog -J2VwX3JlcG9ydF9ncm91cGluZycgfSApOwoJCQkJCQl0YXJnZXRfZWwuaW5zZXJ0KCB7ICdiZWZv -cmUnIDogZ3JvdXBpbmdfY29udGFpbmVyIH0gKTsKCQkJCQkJZ3JvdXBpbmdfY29udGFpbmVyLnVw -ZGF0ZSggdGhpcy5ncm91cGVkX2lkc1tpXS5sYWJlbCApOwoJCQkJCX0KCQkJCX0KCgkJCQkvL2Fk -ZCB0aGUgZXByaW50IHN1bW1hcmllcwoJCQkJdmFyIGFkZGVkX2lkcyA9IHt9OwoJCQkJZm9yKCB2 -YXIgYyA9IDA7IGMgPCB0aGlzLmlkcy5sZW5ndGg7IGMrKyApCgkJCQl7CgkJCQkJdmFyIGRhdGFv -YmppZCA9IHRoaXMuaWRzW2NdOwoJCQkJCXZhciBlbnRyeSA9IHRoaXMuZGF0YW9ianNbZGF0YW9i -amlkXTsKCgkJCQkJLy9zdG9yZSB0aGF0IHdlIGhhdmUgYWRkZWQgdGhpcyBvYmplY3RpZAoJCQkJ -CWlmKCAhKGRhdGFvYmppZCBpbiBhZGRlZF9pZHMpICkKCQkJCQl7CgkJCQkJCWFkZGVkX2lkc1tk -YXRhb2JqaWRdID0gMDsKCQkJCQl9CgkJCQkJZWxzZQoJCQkJCXsKCQkJCQkJYWRkZWRfaWRzW2Rh -dGFvYmppZF0gPSBhZGRlZF9pZHNbZGF0YW9iamlkXSArIDE7CgkJCQkJfQoJCQkJCXRoaXMudG90 -YWxfZGF0YW9ianMrKzsKCgkJCQkJdmFyIHN1bW1hcnkgPSBlbnRyeS5zdW1tYXJ5OwoKCQkJCQl2 -YXIgdGFyZ2V0X2lkID0gdGhpcy5wcmVmaXggKyAnXycgKyBkYXRhb2JqaWQ7CgkJCQkJaWYoIGFk -ZGVkX2lkc1tkYXRhb2JqaWRdID4gMCApCgkJCQkJewoJCQkJCQl0YXJnZXRfaWQgPSB0YXJnZXRf -aWQgKyAnXycgKyBhZGRlZF9pZHNbZGF0YW9iamlkXTsKCQkJCQl9CgkJCQkJdmFyIHRhcmdldF9l -bCA9ICQoIHRhcmdldF9pZCApOwoKCQkJCQlpZiggdGFyZ2V0X2VsICE9IG51bGwgJiYgc3VtbWFy -eSAhPSBudWxsICkKCQkJCQl7CgkJCQkJCXZhciBzdW1tYXJ5X2VsID0gdGFyZ2V0X2VsLmFwcGVu -ZENoaWxkKCBuZXcgRWxlbWVudCggJ2RpdicsIHsgJ2NsYXNzJzogJ2VwX3JlcG9ydF9yb3dfc3Vt -bWFyeScgfSApICk7CgkJCQkJCXN1bW1hcnlfZWwudXBkYXRlKCBzdW1tYXJ5ICk7CgoJCQkJCQkv -L3RvdGFsIHVwIG5vbiBjb21wbGlhbnQgcmVjb3JkcwoJCQkJCQlpZiggZW50cnkuaXNfY29tcGxp -YW50ID09IG51bGwgJiYgZW50cnkucHJvYmxlbXMgJiYgZW50cnkucHJvYmxlbXMubGVuZ3RoICkK -CQkJCQkJewoJCQkJCQkJdGhpcy50b3RhbF9ub25jb21wbGlhbnQrKzsKCQkJCQkJfQoKCQkJCQkJ -aWYoIGVudHJ5LnByb2JsZW1zICYmIGVudHJ5LnByb2JsZW1zLmxlbmd0aCApCgkJCQkJCXsKCQkJ -CQkJCXZhciBwcm9ibGVtc19lbCA9IHRhcmdldF9lbC5hcHBlbmRDaGlsZCggbmV3IEVsZW1lbnQo -ICd1bCcsIHsgJ2NsYXNzJzogJ2VwX3JlcG9ydF9yb3dfcHJvYmxlbXMnIH0gKSApOwoKCQkJCQkJ -CWZvciggdmFyIHA9MDsgcDwgZW50cnkucHJvYmxlbXMubGVuZ3RoOyBwKysgKQoJCQkJCQkJewoJ -CQkJCQkJCXZhciBsaSA9IHByb2JsZW1zX2VsLmFwcGVuZENoaWxkKCBuZXcgRWxlbWVudCggJ2xp -JyApKTsKCQkJCQkJCQlsaS51cGRhdGUoIGVudHJ5LnByb2JsZW1zW3BdICk7CgkJCQkJCQl9CgkJ -CQkJCX0KCQkJCQkJZWxzZQoJCQkJCQl7CgkJCQkJCQkvL2FkZCBzdXBwb3J0IGZvciBjb21wbGlh -bnQgaXRlbXMgdG8gaW5jbHVkZSBidWxsZXQgcG9pbnRzIHRvbwoJCQkJCQkJaWYoIGVudHJ5LmJ1 -bGxldHMgJiYgZW50cnkuYnVsbGV0cy5sZW5ndGggKQoJCQkJCQkJewoJCQkJCQkJCXZhciBidWxs -ZXRzX2VsID0gdGFyZ2V0X2VsLmFwcGVuZENoaWxkKCBuZXcgRWxlbWVudCggJ3VsJywgeyAnY2xh -c3MnOiAnZXBfcmVwb3J0X3Jvd19idWxsZXRzJyB9ICkgKTsKCgkJCQkJCQkJZm9yKCB2YXIgYj0w -OyBiPCBlbnRyeS5idWxsZXRzLmxlbmd0aDsgYisrICkKCQkJCQkJCQl7CgkJCQkJCQkJCXZhciBs -aSA9IGJ1bGxldHNfZWwuYXBwZW5kQ2hpbGQoIG5ldyBFbGVtZW50KCAnbGknICkpOwoJCQkJCQkJ -CQlsaS51cGRhdGUoIGVudHJ5LmJ1bGxldHNbYl0gKTsKCQkJCQkJCQl9CgkJCQkJCQl9CgkJCQkJ -CX0KCgkJCQkJCS8vZGlzcGxheSBzdGF0ZQoJCQkJCQl2YXIgcmUgPSBuZXcgUmVnRXhwKCJeIyg/ -OlswLTlhLWZBLUZdezN9KXsxLDJ9JCIpOwoJCQkJCQlpZiggZW50cnkuc3RhdGUgJiYgcmUudGVz -dChlbnRyeS5zdGF0ZSkgKQoJCQkJCQl7CgkJCQkJCQl0YXJnZXRfZWwuc3R5bGUuYm9yZGVyTGVm -dFdpZHRoID0gJzdweCc7CgkJCQkJCQl0YXJnZXRfZWwuc3R5bGUuYm9yZGVyTGVmdFN0eWxlID0g -J3NvbGlkJzsKCQkJCQkJCXRhcmdldF9lbC5zdHlsZS5ib3JkZXJMZWZ0Q29sb3IgPSBlbnRyeS5z -dGF0ZTsKCQkJCQkJfQoJCQkJCQllbHNlIC8vbm8gc3RhdGUgcHJvdmlkZWQsIHNvIGRlcml2ZSBv -bmUgZnJvbSBleGlzdGVuY2Ugb2YgcHJvYmxlbXMKCQkJCQkJewoJCQkJCQkJaWYoIGVudHJ5LnBy -b2JsZW1zICYmIGVudHJ5LnByb2JsZW1zLmxlbmd0aCApCgkJCQkJCQl7CgkJCQkJCQkJdGFyZ2V0 -X2VsLmFkZENsYXNzTmFtZSggJ2VwX3JlcG9ydF9yb3dfcHJvYmxlbXMnICk7CgkJCQkJCQl9CgkJ -CQkJCQllbHNlCgkJCQkJCQl7CgkJCQkJCQkJdGFyZ2V0X2VsLmFkZENsYXNzTmFtZSggJ2VwX3Jl -cG9ydF9yb3dfb2snICk7CgkJCQkJCQl9CgoJCQkJCQkJaWYoICF0aGlzLnNob3dfY29tcGxpYW5j -ZSApCgkJCQkJCQl7CgkJCQkJCQkJdGFyZ2V0X2VsLmFkZENsYXNzTmFtZSggJ2VwX3JlcG9ydF9y -b3dfbm9fY29tcGxpYW5jZScgKTsKCQkJCQkJCX0KCQkJCQkJfQoJCQkJCQl0YXJnZXRfZWwuc2hv -dygpOwoKCQkJCQkJdmFyIGdyb3VwaW5nID0gZW50cnkuZ3JvdXBpbmc7CgkJCQkJCWlmKCBncm91 -cGluZyAhPSBudWxsICkKCQkJCQkJewoJCQkJCQkJaWYoIHRoaXMuY3VycmVudF9ncm91cGluZyA9 -PSBudWxsIHx8IHRoaXMuY3VycmVudF9ncm91cGluZyAhPSBncm91cGluZykKCQkJCQkJCXsKCQkJ -CQkJCQl0aGlzLmN1cnJlbnRfZ3JvdXBpbmcgPSBncm91cGluZzsKCQkJCQkJCQl2YXIgZ3JvdXBp -bmdfY29udGFpbmVyID0gbmV3IEVsZW1lbnQoICdkaXYnLCB7ICdjbGFzcyc6ICdlcF9yZXBvcnRf -Z3JvdXBpbmcnIH0gKTsKCQkJCQkJCQl0YXJnZXRfZWwuaW5zZXJ0KCB7ICdiZWZvcmUnIDogZ3Jv -dXBpbmdfY29udGFpbmVyIH0gKTsKCQkJCQkJCQlncm91cGluZ19jb250YWluZXIudXBkYXRlKCB0 -aGlzLmN1cnJlbnRfZ3JvdXBpbmcgKTsKCQkJCQkJCX0KCQkJCQkJfQoJCQkJCX0KCQkJCX0KCgoJ -CQkJaWYoIHRoaXMudG90YWxfZGF0YW9ianMgKQoJCQkJewoKCQkJCQl0aGlzLmNvbnRhaW5lci5p -bnNlcnRCZWZvcmUoIG5ldyBFbGVtZW50KCAnZGl2JywgeyAnY2xhc3MnOiAnZXBfcmVwb3J0X2Nv -bXBsaWFuY2VfY29udGFpbmVyJywgJ2lkJzogdGhpcy5wcmVmaXggKyAiX2NvbXBsaWFuY2VfY29u -dGFpbmVyIiB9ICksIHRoaXMuY29udGFpbmVyLmZpcnN0Q2hpbGQgKTsKCQkJCQkvL3NldCB1cCB0 -ZXh0IGNvbnRhaW5lcgoJCQkJCSQoIHRoaXMucHJlZml4ICsgIl9jb21wbGlhbmNlX2NvbnRhaW5l -ciIgKS5hcHBlbmRDaGlsZCggbmV3IEVsZW1lbnQoICdkaXYnLCB7ICdjbGFzcyc6ICdlcF9yZXBv -cnRfY29tcGxpYW5jZV90ZXh0JywgJ2lkJzogdGhpcy5wcmVmaXggKyAiX2NvbXBsaWFuY2VfdGV4 -dCIsICB9ICkpOwoKCQkJCQkvL3NldCB1cCBvdXRwdXRzIGxhYmVsCgkJCQkJdmFyIG91dHB1dHM7 -CgkJCQkJaWYoIHRoaXMubGFiZWxzICkKCQkJCQl7CgkJCQkJCW91dHB1dHMgPSB0aGlzLmxhYmVs -cy5vdXRwdXRzOwoJCQkJCX0KCQkJCQllbHNlCgkJCQkJewoJCQkJCQlvdXRwdXRzID0gIm91dHB1 -dCI7CgkJCQkJCWlmKCB0aGlzLnRvdGFsX2RhdGFvYmpzID4gMSApCgkJCQkJCQlvdXRwdXRzID0g -b3V0cHV0cyArICJzIjsKCQkJCQl9CgoJCQkJCWlmKCB0aGlzLnNob3dfY29tcGxpYW5jZSApCgkJ -CQkJewoJCQkJCQl2YXIgcmVmX3dpZHRoID0gMjAwOwoJCQkJCQl2YXIgY29tcGxpYW5jZSA9ICgg -dGhpcy50b3RhbF9kYXRhb2JqcyAtIHRoaXMudG90YWxfbm9uY29tcGxpYW50ICkgLyB0aGlzLnRv -dGFsX2RhdGFvYmpzOwoKCQkJCQkJJCggdGhpcy5wcmVmaXggKyAiX2NvbXBsaWFuY2VfY29udGFp -bmVyIiApLmFwcGVuZENoaWxkKCBuZXcgRWxlbWVudCggJ2RpdicsIHsgJ2NsYXNzJzogJ2VwX3Jl -cG9ydF9jb21wbGlhbmNlX3dyYXBwZXInLCAnaWQnOiB0aGlzLnByZWZpeCArICJfY29tcGxpYW5j -ZSIsICdzdHlsZSc6ICd3aWR0aDogJytyZWZfd2lkdGggKyAncHgnIH0gKSApOwoKCQkJCQkJdmFy -IGNvbXBsaWFuY2Vfd2lkdGggPSBNYXRoLmZsb29yKCAyMDAgKiBjb21wbGlhbmNlICk7CgoJCQkJ -CQkkKCB0aGlzLnByZWZpeCArICJfY29tcGxpYW5jZSIgKS5hcHBlbmRDaGlsZCggbmV3IEVsZW1l -bnQoICdkaXYnLCB7ICdjbGFzcyc6ICdlcF9yZXBvcnRfY29tcGxpYW5jZScsICdzdHlsZSc6ICd3 -aWR0aDonK2NvbXBsaWFuY2Vfd2lkdGggKyAncHgnIH0gKSApOwoKCQkJCQkJJCggdGhpcy5wcmVm -aXggKyAiX2NvbXBsaWFuY2VfdGV4dCIgKS51cGRhdGUoIHRoaXMudG90YWxfZGF0YW9ianMgKyAi -ICIgKyBvdXRwdXRzICsgIiAtICIgKyBNYXRoLmZsb29yKCBjb21wbGlhbmNlICogMTAwICkgKyAi -JSBjb21wbGlhbmNlIik7CgkJCQkJfQoJCQkJCWVsc2UKCQkJCQl7CgkJCQkJCSQoIHRoaXMucHJl -Zml4ICsgIl9jb21wbGlhbmNlX3RleHQiICkudXBkYXRlKCB0aGlzLnRvdGFsX2RhdGFvYmpzICsg -IiAiICsgb3V0cHV0cyApOwoJCQkJCX0KCQkJCX0KCgkJCX0KCQkJZWxzZQoJCQl7CgkJCQl2YXIg -d2lkdGggPSAyMDA7CgkJCQkkKCB0aGlzLnByZWZpeCArICdfcHJvZ3Jlc3NfYmFyJyApLnN0eWxl -LmJhY2tncm91bmRQb3NpdGlvbiA9IE1hdGgucm91bmQoLXdpZHRoICsgd2lkdGggKiB0aGlzLmNv -dW50IC8gdGhpcy5pZHMubGVuZ3RoKSArICJweCAwcHgiOwoJCQl9CgoJCQlpZiggdGhpcy5ydW5z -ID09IDAgJiYgdGhpcy5jb3VudCA9PSAwICkKCQkJewoJCQkJdmFyIHBOb2RlID0gJCggdGhpcy5w -cmVmaXggKyAnX3Byb2dyZXNzX2JhcicgKS5wYXJlbnROb2RlOwoJCQkJJCh0aGlzLnByZWZpeCAr -ICdfcHJvZ3Jlc3NfYmFyJykucmVtb3ZlKCk7CgkJCQl2YXIgc3BhbiA9IG5ldyBFbGVtZW50KCAn -c3BhbicsIHsgJ2NsYXNzJzogJ2VwX3JlZl9yZXBvcnRfZW1wdHknIH0gKTsKCQkJCXNwYW4udXBk -YXRlKCAnUmVwb3J0IGVtcHR5JyApOwoJCQkJcE5vZGUuaW5zZXJ0KCBzcGFuICk7CgkJCX0KCQkJ -dGhpcy5ydW5zKys7CgoJCX0pLmJpbmQobG9hZGVyKQoJfSk7Cn0KCmZ1bmN0aW9uIGdyb3VwX3Jl -cG9ydChncm91cCkKewoJZG9jdW1lbnQuZ3JvdXBfcmVwb3J0Lmdyb3VwLnZhbHVlID0gZ3JvdXA7 -Cglkb2N1bWVudC5ncm91cF9yZXBvcnQuc3VibWl0KCk7Cn0KCmZ1bmN0aW9uIHNvcnRfcmVwb3J0 -KHNvcnQpCnsKCWRvY3VtZW50LnNvcnRfcmVwb3J0LnNvcnQudmFsdWUgPSBzb3J0OwoJZG9jdW1l -bnQuc29ydF9yZXBvcnQuc3VibWl0KCk7Cn0KCmZ1bmN0aW9uIGlzSW50ZWdlcihudW0pIHsKICBy -ZXR1cm4gKG51bSBeIDApID09PSBudW07Cn0K +ICAgIH0pOwp9OwoKCnZhciBvbkZvcm1TZWxlY3QgPSBmdW5jdGlvbigpewogICAgLy9nZXQgZm9y +bSBpZAogICAgdmFyIGZvcm1pZCA9IHRoaXMub3B0aW9uc1t0aGlzLnNlbGVjdGVkSW5kZXhdLmdl +dEF0dHJpYnV0ZSgnZm9ybScpOwogICAgY29uc3QgY29udGFpbmVyID0gZG9jdW1lbnQuZ2V0RWxl +bWVudEJ5SWQoImZvcm1fY29udGFpbmVyIik7CiAgICBjb250YWluZXIuaW5uZXJIVE1MID0gJyc7 +CiAgICBjb25zdCBjbG9uZSA9ICQoZm9ybWlkKS5jb250ZW50LmNsb25lTm9kZSh0cnVlKTsKICAg +IGNvbnRhaW5lci5hcHBlbmRDaGlsZChjbG9uZSk7Cn07CgovLyBVc2VkIGJ5IHRoZSBTY3JlZW46 +OlJlcG9ydDo6cmVuZGVyIG1ldGhvZAoKdmFyIEVQcmludHNfU2NyZWVuX1JlcG9ydF9Mb2FkZXIg +PSBDbGFzcy5jcmVhdGUoewogICAgaGFzX3Byb2JsZW1zOiAwLAogICAgY291bnQ6IDAsCiAgICBy +dW5zOiAwLAogICAgcHJvZ3Jlc3M6IG51bGwsCiAgICBpZHM6IEFycmF5KCksCiAgICBzZWVuX2lk +czoge30sCiAgICBzdGVwOiAyMCwKICAgIGJhdGNoOiAwLAogICAgZ3JvdXBlZDogZmFsc2UsCiAg +ICBwcmVmaXg6ICcnLAogICAgb25Qcm9ibGVtczogZnVuY3Rpb24oKSB7fSwKICAgIG9uRmluaXNo +OiBmdW5jdGlvbigpIHt9LAogICAgdXJsOiAiIiwKICAgIHBhcmFtZXRlcnM6ICIiLAogICAgY29u +dGFpbmVyOiBudWxsLAogICAgc2hvd19jb21wbGlhbmNlOiAxLCAKCiAgICAvLyB0byBzaG93IGEg +cHJldHR5IHByb2dyZXNzIGJhciAoJSBjb21wbGlhbmNlKToKICAgIHRvdGFsX2RhdGFvYmpzOiAw +LAogICAgdG90YWxfbm9uY29tcGxpYW50OiAwLAoKCiAgICBpbml0aWFsaXplOiBmdW5jdGlvbihv +cHRzKSB7CiAgICAgICAgaWYoIG9wdHMuaWRzICkKICAgICAgICAgICAgdGhpcy5pZHMgPSBvcHRz +LmlkczsKICAgICAgICBpZiggb3B0cy5zdGVwICkKICAgICAgICAgICAgdGhpcy5zdGVwID0gb3B0 +cy5zdGVwOwogICAgICAgIGlmKCBvcHRzLnByZWZpeCApCiAgICAgICAgICAgIHRoaXMucHJlZml4 +ID0gb3B0cy5wcmVmaXg7CiAgICAgICAgaWYoIG9wdHMub25GaW5pc2ggKQogICAgICAgICAgICB0 +aGlzLm9uRmluaXNoID0gb3B0cy5vbkZpbmlzaDsKICAgICAgICBpZiggb3B0cy5vblByb2JsZW1z +ICkKICAgICAgICAgICAgdGhpcy5vblByb2JsZW1zID0gb3B0cy5vblByb2JsZW1zOwogICAgICAg +IGlmKCBvcHRzLnVybCApCiAgICAgICAgewogICAgICAgICAgICB0aGlzLnVybCA9IG9wdHMudXJs +OwogICAgICAgIH0KICAgICAgICBpZiggb3B0cy5wYXJhbWV0ZXJzICkKICAgICAgICAgICAgdGhp +cy5wYXJhbWV0ZXJzID0gb3B0cy5wYXJhbWV0ZXJzOwogICAgICAgIGlmKCBvcHRzLmNvbnRhaW5l +cl9pZCApCiAgICAgICAgICAgIHRoaXMuY29udGFpbmVyID0gJCggb3B0cy5jb250YWluZXJfaWQg +KTsgICAgLy8gc2hvdWxkIGZhaWwgaWYgY29udGFpbmVyIGRvZXNuJ3QgZXhpc3QuLi4KICAgICAg +ICBpZiggb3B0cy5oYXNPd25Qcm9wZXJ0eSgnc2hvd19jb21wbGlhbmNlJykgKQogICAgICAgIHsK +ICAgICAgICAgICAgdGhpcy5zaG93X2NvbXBsaWFuY2UgPSBvcHRzLnNob3dfY29tcGxpYW5jZTsK +ICAgICAgICB9CiAgICAgICAgaWYoIG9wdHMubGFiZWxzICkKICAgICAgICB7CiAgICAgICAgICAg +IHRoaXMubGFiZWxzID0gb3B0cy5sYWJlbHM7CiAgICAgICAgfQogICAgfSwKCiAgICAvLyBicmVh +ayBkb3duIHRoZSByZXF1ZXN0cyBpbnRvIGJhdGNoZXMgYXMgZGVmaW5lZCBieSB0aGUgc3RlcCBz +aXplCiAgICAvLyBkb24ndCBtb3ZlIG9uIHRvIHRoZSBuZXh0IGJhdGNoIHVudGlsIHdlJ3ZlIGhh +bmRsZWQgdGhlIHByZXZpb3VzIG9uZQogICAgcnVuQmF0Y2g6IGZ1bmN0aW9uKCkgewogICAgCiAg +ICAgICAgdmFyIGRhdGFvYmpzID0ge307CgogICAgICAgIHZhciBpID0gdGhpcy5iYXRjaCAqIHRo +aXMuc3RlcDsKICAgICAgICAKICAgICAgICAvLyBhcmd1bWVudHMgZm9yIEFqYXggcXVlcnkgQU5E +IGNyZWF0ZXMgdGhlIEhUTUwgcGxhY2Vob2xkZXJzIDxkaXY+J3MgKHRoYXQgd2lsbCByZWNlaXZl +IHRoZSBjb250ZW50IG9mIHRoZSBBamF4IHF1ZXJ5Li4uKSAgICAgICAgICAgICAgCiAgICAgICAg +dmFyIGFyZ3MgPSAnJmFqYXg9Jyt0aGlzLnByZWZpeAoKICAgICAgICAvLyBidWlsZCB1cCBvdXIg +cmVxdWVzdCBmb3IgdGhpcyBzdGVwJ3MgcmVzdWx0cwogICAgICAgIGZvcih2YXIgaiA9IDA7IGog +PCB0aGlzLnN0ZXAgJiYgaStqIDwgdGhpcy5pZHMubGVuZ3RoOyBqKyspCiAgICAgICAgewogICAg +ICAgICAgICBhcmdzICs9ICcmJyArIHRoaXMucHJlZml4ICsgJz0nICsgdGhpcy5pZHNbaStqXTsK +ICAgICAgICAgICAgdmFyIGlkID0gdGhpcy5wcmVmaXggKyAnXycgKyB0aGlzLmlkc1tpK2pdOwog +ICAgICAgICAgICB2YXIgdGFyZ2V0X2VsID0gJCggaWQgKTsKICAgICAgICAgICAgaWYoIHRhcmdl +dF9lbCAhPSBudWxsICkKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgLy9zdG9yZSBhIHJl +Y29yZCBvZiB0aGlzIGluIHNlZW5faWRzIHRvIGVuc3VyZSBlYWNoIHBsYWNlaG9sZGVyIGhhcyBh +IHVuaXF1ZSBpZAogICAgICAgICAgICAgICAgaWYoICEoaWQgaW4gdGhpcy5zZWVuX2lkcykgKQog +ICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIHRoaXMuc2Vlbl9pZHNbaWRdID0g +MTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAg +IHsKICAgICAgICAgICAgICAgICAgICB0aGlzLnNlZW5faWRzW2lkXSA9IHRoaXMuc2Vlbl9pZHNb +aWRdICsgMTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIGlkID0gaWQgKyAiXyIg +KyB0aGlzLnNlZW5faWRzW2lkXTsKICAgICAgICAgICAgfQogICAgICAgICAgICAKICAgICAgICAg +ICAgLy8gc2V0IHVwIGFuIGVsZW1lbnQgZm9yIHRoaXMgcmVzdWx0ICAgICAgICAKICAgICAgICAg +ICAgdGhpcy5jb250YWluZXIuaW5zZXJ0KCBuZXcgRWxlbWVudCggJ2RpdicsIHsgJ2NsYXNzJzog +J2VwX3JlcG9ydF9yb3cnLCAnaWQnOiBpZCwgJ3Bvc2l0aW9uJzogaStqIH0gKSwgeyAncG9zaXRp +b24nOiAnYWZ0ZXInIH0gKTsKICAgICAgICB9CgogICAgICAgIG5ldyBBamF4LlJlcXVlc3QoIHRo +aXMudXJsLCB7CiAgICAgICAgICAgIG1ldGhvZDogJ2dldCcsCiAgICAgICAgICAgIHBhcmFtZXRl +cnM6IHRoaXMucGFyYW1ldGVycyArIGFyZ3MsCiAgICAgICAgICAgIG9uU3VjY2VzczogKGZ1bmN0 +aW9uKHRyYW5zcG9ydCkgewoKICAgICAgICAgICAgICAgIC8vIHdlIGdvdCBvdXIgcmVwb3J0IGRh +dGEgYmFjayBmcm9tIHRoZSBwbHVnaW4KICAgICAgICAgICAgICAgIHZhciBqc29uID0gdHJhbnNw +b3J0LnJlc3BvbnNlVGV4dC5ldmFsSlNPTigpOwogICAgICAgICAgICAgICAgdmFyIGRhdGEgPSBq +c29uLmRhdGE7CiAgICAgICAgICAgICAgICBpZiggZGF0YSA9PSBudWxsICkKICAgICAgICAgICAg +ICAgIHsKICAgICAgICAgICAgICAgICAgICBkYXRhID0gbmV3IEFycmF5KCk7CiAgICAgICAgICAg +ICAgICB9CiAgICAgICAgCiAgICAgICAgICAgICAgICBmb3IoIHZhciBuID0gMDsgbiA8IGRhdGEu +bGVuZ3RoOyBuKysgKQogICAgICAgICAgICAgICAgeyAgICAgICAgICAgICAgICAgICAgICAgCiAg +ICAgICAgICAgICAgICAgICAgdmFyIGVudHJ5ID0gZGF0YVtuXTsKICAgICAgICAKICAgICAgICAg +ICAgICAgICAgICAvLyBubyBlbnRyeSAtIGF3a3dhcmQgICAgICAgIAogICAgICAgICAgICAgICAg +ICAgIGlmKCBlbnRyeSA9PSBudWxsICkKICAgICAgICAgICAgICAgICAgICB7CiAgICAgICAgICAg +ICAgICAgICAgICAgIGNvbnRpbnVlOwogICAgICAgICAgICAgICAgICAgIH0KCiAgICAgICAgICAg +ICAgICAgICAgLy8gbm8gZGF0YW9iaiBpZCAtIGFsc28gYXdrd2FyZAogICAgICAgICAgICAgICAg +ICAgIHZhciBkYXRhb2JqaWQgPSBlbnRyeS5kYXRhb2JqaWQ7CiAgICAgICAgICAgICAgICAgICAg +aWYoIGRhdGFvYmppZCA9PSBudWxsICkKICAgICAgICAgICAgICAgICAgICB7CiAgICAgICAgICAg +ICAgICAgICAgICAgIGNvbnRpbnVlOwogICAgICAgICAgICAgICAgICAgIH0KCiAgICAgICAgICAg +ICAgICAgICAgLy8gd2UgaGF2ZSBhIGRhdGFvYmosIGxldCdzIHJlY29yZCBpdC4uLgogICAgICAg +ICAgICAgICAgICAgIGlmKCAhKGRhdGFvYmppZCBpbiBkYXRhb2JqcykgKQogICAgICAgICAgICAg +ICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAgICAgdGhpcy5jb3VudCsrOwogICAgICAgICAg +ICAgICAgICAgICAgICBkYXRhb2Jqc1tkYXRhb2JqaWRdID0gZW50cnk7CiAgICAgICAgICAgICAg +ICAgICAgfQogICAgICAgICAgICAgICAgfQoKICAgICAgICAgICAgICAgIC8vYWRkIHRoZSBlcHJp +bnQgc3VtbWFyaWVzIGZvciB0aGlzIHN0ZXAKICAgICAgICAgICAgICAgIHZhciBhZGRlZF9pZHMg +PSB7fTsgCgogICAgICAgICAgICAgICAgLy9mb3IoIHZhciBjID0gdGhpcy5iYXRjaCAqIHRoaXMu +c3RlcDsgYyA8ICh0aGlzLmJhdGNoICogdGhpcy5zdGVwKSArIHRoaXMuc3RlcDsgYysrICkKICAg +ICAgICAgICAgICAgIGZvciggdmFyIGMgPSAwOyBjIDwgdGhpcy5zdGVwICYmIGkrYyA8IHRoaXMu +aWRzLmxlbmd0aDsgYysrICkKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICB2 +YXIgZGF0YW9iamlkID0gdGhpcy5pZHNbaStjXTsKICAgICAgICAgICAgICAgICAgICB2YXIgZW50 +cnkgPSBkYXRhb2Jqc1tkYXRhb2JqaWRdOwoKICAgICAgICAgICAgICAgICAgICAvL3N0b3JlIHRo +YXQgd2UgaGF2ZSBhZGRlZCB0aGlzIG9iamVjdGlkCiAgICAgICAgICAgICAgICAgICAgaWYoICEo +ZGF0YW9iamlkIGluIGFkZGVkX2lkcykgKQogICAgICAgICAgICAgICAgICAgIHsKICAgICAgICAg +ICAgICAgICAgICAgICAgYWRkZWRfaWRzW2RhdGFvYmppZF0gPSAwOwogICAgICAgICAgICAgICAg +ICAgIH0KICAgICAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICAgICAgewogICAg +ICAgICAgICAgICAgICAgICAgICBhZGRlZF9pZHNbZGF0YW9iamlkXSA9IGFkZGVkX2lkc1tkYXRh +b2JqaWRdICsgMTsKICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgdGhp +cy50b3RhbF9kYXRhb2JqcysrOwoKICAgICAgICAgICAgICAgICAgICB2YXIgc3VtbWFyeSA9IGVu +dHJ5LnN1bW1hcnk7CgogICAgICAgICAgICAgICAgICAgIHZhciB0YXJnZXRfaWQgPSB0aGlzLnBy +ZWZpeCArICdfJyArIGRhdGFvYmppZDsKICAgICAgICAgICAgICAgICAgICBpZiggYWRkZWRfaWRz +W2RhdGFvYmppZF0gPiAwICkKICAgICAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAg +ICAgICAgIHRhcmdldF9pZCA9IHRhcmdldF9pZCArICdfJyArIGFkZGVkX2lkc1tkYXRhb2JqaWRd +OwogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICB2YXIgdGFyZ2V0X2Vs +ID0gJCggdGFyZ2V0X2lkICk7CgogICAgICAgICAgICAgICAgICAgIGlmKCB0YXJnZXRfZWwgIT0g +bnVsbCAmJiBzdW1tYXJ5ICE9IG51bGwgKQogICAgICAgICAgICAgICAgICAgIHsKICAgICAgICAg +ICAgICAgICAgICAgICAgdmFyIHN1bW1hcnlfZWwgPSB0YXJnZXRfZWwuYXBwZW5kQ2hpbGQoIG5l +dyBFbGVtZW50KCAnZGl2JywgeyAnY2xhc3MnOiAnZXBfcmVwb3J0X3Jvd19zdW1tYXJ5JyB9ICkg +KTsKICAgICAgICAgICAgICAgICAgICAgICAgc3VtbWFyeV9lbC51cGRhdGUoIHN1bW1hcnkgKTsK +CiAgICAgICAgICAgICAgICAgICAgICAgIC8vdG90YWwgdXAgbm9uIGNvbXBsaWFudCByZWNvcmRz +CiAgICAgICAgICAgICAgICAgICAgICAgIGlmKCBlbnRyeS5pc19jb21wbGlhbnQgPT0gbnVsbCAm +JiBlbnRyeS5wcm9ibGVtcyAmJiBlbnRyeS5wcm9ibGVtcy5sZW5ndGggKQogICAgICAgICAgICAg +ICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICB0aGlzLnRvdGFsX25vbmNv +bXBsaWFudCsrOwogICAgICAgICAgICAgICAgICAgICAgICB9CiAKICAgICAgICAgICAgICAgICAg +ICAgICAgLy9hZGQgc3VwcG9ydCBmb3IgY29tcGxpYW50IGl0ZW1zIHRvIGluY2x1ZGUgYnVsbGV0 +IHBvaW50cyB0b28KICAgICAgICAgICAgICAgICAgICAgICAgaWYoIGVudHJ5LmJ1bGxldHMgJiYg +ZW50cnkuYnVsbGV0cy5sZW5ndGggKQogICAgICAgICAgICAgICAgICAgICAgICB7CiAgICAgICAg +ICAgICAgICAgICAgICAgICAgICB2YXIgYnVsbGV0c19lbCA9IHRhcmdldF9lbC5hcHBlbmRDaGls +ZCggbmV3IEVsZW1lbnQoICd1bCcsIHsgJ2NsYXNzJzogJ2VwX3JlcG9ydF9yb3dfYnVsbGV0cycg +fSApICk7CgogICAgICAgICAgICAgICAgICAgICAgICAgICAgZm9yKCB2YXIgYiA9IDA7IGIgPCBl +bnRyeS5idWxsZXRzLmxlbmd0aDsgYisrICkKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHsK +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2YXIgbGkgPSBidWxsZXRzX2VsLmFwcGVu +ZENoaWxkKCBuZXcgRWxlbWVudCggJ2xpJyApKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICBsaS51cGRhdGUoIGVudHJ5LmJ1bGxldHNbYl0gKTsKICAgICAgICAgICAgICAgICAgICAg +ICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgICAgfQoKICAgICAgICAgICAgICAgICAgICAg +ICAgaWYoIGVudHJ5LnByb2JsZW1zICYmIGVudHJ5LnByb2JsZW1zLmxlbmd0aCApCiAgICAgICAg +ICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZhciBwcm9ibGVt +c19lbCA9IHRhcmdldF9lbC5hcHBlbmRDaGlsZCggbmV3IEVsZW1lbnQoICd1bCcsIHsgJ2NsYXNz +JzogJ2VwX3JlcG9ydF9yb3dfcHJvYmxlbXMnIH0gKSApOwoKICAgICAgICAgICAgICAgICAgICAg +ICAgICAgIGZvciggdmFyIHAgPSAwOyBwIDwgZW50cnkucHJvYmxlbXMubGVuZ3RoOyBwKysgKQog +ICAgICAgICAgICAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgIHZhciBsaSA9IHByb2JsZW1zX2VsLmFwcGVuZENoaWxkKCBuZXcgRWxlbWVudCggJ2xpJyAp +KTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBsaS51cGRhdGUoIGVudHJ5LnByb2Js +ZW1zW3BdICk7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICB9ICAgICAgICAgICAgICAgICAg +ICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICB9CgogICAgICAgICAgICAgICAg +ICAgICAgICAvL2Rpc3BsYXkgc3RhdGUKICAgICAgICAgICAgICAgICAgICAgICAgdmFyIHJlID0g +bmV3IFJlZ0V4cCgiXiMoPzpbMC05YS1mQS1GXXszfSl7MSwyfSQiKTsKICAgICAgICAgICAgICAg +ICAgICAgICAgaWYoIGVudHJ5LnN0YXRlICYmIHJlLnRlc3QoZW50cnkuc3RhdGUpICkKICAgICAg +ICAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgdGFyZ2V0X2Vs +LnN0eWxlLmJvcmRlckxlZnRXaWR0aCA9ICc3cHgnOwogICAgICAgICAgICAgICAgICAgICAgICAg +ICAgdGFyZ2V0X2VsLnN0eWxlLmJvcmRlckxlZnRTdHlsZSA9ICdzb2xpZCc7CiAgICAgICAgICAg +ICAgICAgICAgICAgICAgICB0YXJnZXRfZWwuc3R5bGUuYm9yZGVyTGVmdENvbG9yID0gZW50cnku +c3RhdGU7CiAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgICAg +ZWxzZSAvL25vIHN0YXRlIHByb3ZpZGVkLCBzbyBkZXJpdmUgb25lIGZyb20gZXhpc3RlbmNlIG9m +IHByb2JsZW1zCiAgICAgICAgICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAg +ICAgICAgIGlmKCBlbnRyeS5wcm9ibGVtcyAmJiBlbnRyeS5wcm9ibGVtcy5sZW5ndGggKQogICAg +ICAgICAgICAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg +IHRhcmdldF9lbC5hZGRDbGFzc05hbWUoICdlcF9yZXBvcnRfcm93X3Byb2JsZW1zJyApOwogICAg +ICAgICAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgICAgICAgICAgZWxz +ZQogICAgICAgICAgICAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAgICAg +ICAgICAgIHRhcmdldF9lbC5hZGRDbGFzc05hbWUoICdlcF9yZXBvcnRfcm93X29rJyApOwogICAg +ICAgICAgICAgICAgICAgICAgICAgICAgfQoKICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlm +KCAhdGhpcy5zaG93X2NvbXBsaWFuY2UgKQogICAgICAgICAgICAgICAgICAgICAgICAgICAgewog +ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRhcmdldF9lbC5hZGRDbGFzc05hbWUoICdl +cF9yZXBvcnRfcm93X25vX2NvbXBsaWFuY2UnICk7CiAgICAgICAgICAgICAgICAgICAgICAgICAg +ICB9CiAgICAgICAgICAgICAgICAgICAgICAgIH0gICAgICAgICAgICAgICAgICAgICAgICAgICAg +ICAgCiAgICAgICAgICAgICAgICAgICAgICAgIHRhcmdldF9lbC5zaG93KCk7CgogICAgICAgICAg +ICAgICAgICAgICAgICB2YXIgZ3JvdXBpbmcgPSBlbnRyeS5ncm91cGluZzsKICAgICAgICAgICAg +ICAgICAgICAgICAgaWYoIGdyb3VwaW5nICE9IG51bGwgKQogICAgICAgICAgICAgICAgICAgICAg +ICB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICBpZiggY3VycmVudF9ncm91cGluZyA9PSBu +dWxsIHx8IGN1cnJlbnRfZ3JvdXBpbmcgIT0gZ3JvdXBpbmcpCiAgICAgICAgICAgICAgICAgICAg +ICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY3VycmVudF9ncm91cGlu +ZyA9IGdyb3VwaW5nOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZhciBncm91cGlu +Z19jb250YWluZXIgPSBuZXcgRWxlbWVudCggJ2RpdicsIHsgJ2NsYXNzJzogJ2VwX3JlcG9ydF9n +cm91cGluZycgfSApOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRhcmdldF9lbC5p +bnNlcnQoIHsgJ2JlZm9yZScgOiBncm91cGluZ19jb250YWluZXIgfSApOwogICAgICAgICAgICAg +ICAgICAgICAgICAgICAgICAgIGdyb3VwaW5nX2NvbnRhaW5lci51cGRhdGUoIGN1cnJlbnRfZ3Jv +dXBpbmcgKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAg +ICAgICAgfQogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIH0KICAgICAgICAg +ICAgIAogICAgICAgICAgICAgICAgLy8gd2UndmUgcmV0cmlldmVkIGFsbCB0aGUgcmVjb3JkcyAt +IHRoaXMgaXMgdGhlIGZpbmFsIHN0ZXAgc28gdGlkeSB0aGluZ3MgdXAKICAgICAgICAgICAgICAg +IGlmKCB0aGlzLmNvdW50ID09IHRoaXMubm9faXRlbXMgKQogICAgICAgICAgICAgICAgewogICAg +ICAgICAgICAgICAgICAgICQoIHRoaXMucHJlZml4ICsgJ19wcm9ncmVzc19iYXInICkucmVtb3Zl +KCk7CiAgICAgICAgICAgICAgICAgICAgaWYoIHRoaXMuaGFzX3Byb2JsZW1zICkKICAgICAgICAg +ICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAgIHRoaXMub25Qcm9ibGVtcyh0aGlz +KTsKICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgdGhpcy5vbkZpbmlz +aCh0aGlzKTsKICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAg +IC8vYWRkIHRoZSBncm91cCBoZWFkaW5ncwogICAgICAgICAgICAgICAgICAgIGlmKHRoaXMuZ3Jv +dXBlZCkKICAgICAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAgIHZhciBw +b3NpdGlvbiA9IDA7CiAgICAgICAgICAgICAgICAgICAgICAgIGZvciggdmFyIG0gPSAwOyBtIDwg +dGhpcy5ncm91cGVkX2lkcy5sZW5ndGg7IG0rKyApCiAgICAgICAgICAgICAgICAgICAgICAgIHsg +ICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZhciB0YXJnZXRfZWwgPSBkb2N1bWVudC5x +dWVyeVNlbGVjdG9yQWxsKCdbcG9zaXRpb249IicgKyBwb3NpdGlvbiArICciXScpWzBdOwogICAg +ICAgICAgICAgICAgICAgICAgICAgICAgcG9zaXRpb24gPSBwb3NpdGlvbiArIHRoaXMuZ3JvdXBl +ZF9pZHNbbV0ubGlzdC5sZW5ndGg7ICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgIHZhciBn +cm91cGluZ19jb250YWluZXIgPSBuZXcgRWxlbWVudCggJ2RpdicsIHsgJ2NsYXNzJzogJ2VwX3Jl +cG9ydF9ncm91cGluZycgfSApOwogICAgICAgICAgICAgICAgICAgICAgICAgICAgdGFyZ2V0X2Vs +Lmluc2VydCggeyAnYmVmb3JlJyA6IGdyb3VwaW5nX2NvbnRhaW5lciB9ICk7CiAgICAgICAgICAg +ICAgICAgICAgICAgICAgICBncm91cGluZ19jb250YWluZXIudXBkYXRlKCB0aGlzLmdyb3VwZWRf +aWRzW21dLmxhYmVsICk7CiAgICAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAg +ICAgICB9CgogICAgICAgICAgICAgICAgICAgIHRoaXMuY29udGFpbmVyLmluc2VydEJlZm9yZSgg +bmV3IEVsZW1lbnQoICdkaXYnLCB7ICdjbGFzcyc6ICdlcF9yZXBvcnRfY29tcGxpYW5jZV9jb250 +YWluZXInLCAnaWQnOiB0aGlzLnByZWZpeCArICJfY29tcGxpYW5jZV9jb250YWluZXIiIH0gKSwg +dGhpcy5jb250YWluZXIuZmlyc3RDaGlsZCApOwogICAgICAgICAgICAgICAgICAgIAogICAgICAg +ICAgICAgICAgICAgIC8vc2V0IHVwIHRleHQgY29udGFpbmVyCiAgICAgICAgICAgICAgICAgICAg +JCggdGhpcy5wcmVmaXggKyAiX2NvbXBsaWFuY2VfY29udGFpbmVyIiApLmFwcGVuZENoaWxkKCBu +ZXcgRWxlbWVudCggJ2RpdicsIHsgJ2NsYXNzJzogJ2VwX3JlcG9ydF9jb21wbGlhbmNlX3RleHQn +LCAnaWQnOiB0aGlzLnByZWZpeCArICJfY29tcGxpYW5jZV90ZXh0IiwgIH0gKSk7CgogICAgICAg +ICAgICAgICAgICAgIC8vc2V0IHVwIG91dHB1dHMgbGFiZWwKICAgICAgICAgICAgICAgICAgICB2 +YXIgb3V0cHV0czsKICAgICAgICAgICAgICAgICAgICBpZiggdGhpcy5sYWJlbHMgKQogICAgICAg +ICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAgICAgb3V0cHV0cyA9IHRoaXMubGFi +ZWxzLm91dHB1dHM7CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgIGVs +c2UKICAgICAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAgIG91dHB1dHMg +PSAib3V0cHV0IjsKICAgICAgICAgICAgICAgICAgICAgICAgaWYoIHRoaXMudG90YWxfZGF0YW9i +anMgPiAxICkKICAgICAgICAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAg +ICAgICAgb3V0cHV0cyA9IG91dHB1dHMgKyAicyI7CiAgICAgICAgICAgICAgICAgICAgICAgIH0K +ICAgICAgICAgICAgICAgICAgICB9CgogICAgICAgICAgICAgICAgICAgIGlmKCB0aGlzLnNob3df +Y29tcGxpYW5jZSApCiAgICAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAg +ICB2YXIgcmVmX3dpZHRoID0gMjAwOwogICAgICAgICAgICAgICAgICAgICAgICB2YXIgY29tcGxp +YW5jZSA9ICggdGhpcy50b3RhbF9kYXRhb2JqcyAtIHRoaXMudG90YWxfbm9uY29tcGxpYW50ICkg +LyB0aGlzLnRvdGFsX2RhdGFvYmpzOwoKICAgICAgICAgICAgICAgICAgICAgICAgJCggdGhpcy5w +cmVmaXggKyAiX2NvbXBsaWFuY2VfY29udGFpbmVyIiApLmFwcGVuZENoaWxkKCBuZXcgRWxlbWVu +dCggJ2RpdicsIHsgJ2NsYXNzJzogJ2VwX3JlcG9ydF9jb21wbGlhbmNlX3dyYXBwZXInLCAnaWQn +OiB0aGlzLnByZWZpeCArICJfY29tcGxpYW5jZSIsICdzdHlsZSc6ICd3aWR0aDogJytyZWZfd2lk +dGggKyAncHgnIH0gKSApOwoKICAgICAgICAgICAgICAgICAgICAgICAgdmFyIGNvbXBsaWFuY2Vf +d2lkdGggPSBNYXRoLmZsb29yKCAyMDAgKiBjb21wbGlhbmNlICk7CiAgICAKICAgICAgICAgICAg +ICAgICAgICAgICAgJCggdGhpcy5wcmVmaXggKyAiX2NvbXBsaWFuY2UiICkuYXBwZW5kQ2hpbGQo +IG5ldyBFbGVtZW50KCAnZGl2JywgeyAnY2xhc3MnOiAnZXBfcmVwb3J0X2NvbXBsaWFuY2UnLCAn +c3R5bGUnOiAnd2lkdGg6Jytjb21wbGlhbmNlX3dpZHRoICsgJ3B4JyB9ICkgKTsKICAgIAogICAg +ICAgICAgICAgICAgICAgICAgICAkKCB0aGlzLnByZWZpeCArICJfY29tcGxpYW5jZV90ZXh0IiAp +LnVwZGF0ZSggdGhpcy50b3RhbF9kYXRhb2JqcyArICIgIiArIG91dHB1dHMgKyAiIC0gIiArIE1h +dGguZmxvb3IoIGNvbXBsaWFuY2UgKiAxMDAgKSArICIlIGNvbXBsaWFuY2UiKTsKICAgICAgICAg +ICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgICAg +IHsKICAgICAgICAgICAgICAgICAgICAgICAgJCggdGhpcy5wcmVmaXggKyAiX2NvbXBsaWFuY2Vf +dGV4dCIgKS51cGRhdGUoIHRoaXMudG90YWxfZGF0YW9ianMgKyAiICIgKyBvdXRwdXRzICk7CiAg +ICAgICAgICAgICAgICAgICAgfQoKCgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAg +ZWxzZQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIC8vIHVwZGF0ZSBwcm9n +cmVzcyBiYXIKICAgICAgICAgICAgICAgICAgICB2YXIgd2lkdGggPSAyMDA7CiAgICAgICAgICAg +ICAgICAgICAgJCggdGhpcy5wcmVmaXggKyAnX3Byb2dyZXNzX2JhcicgKS5zdHlsZS5iYWNrZ3Jv +dW5kUG9zaXRpb24gPSBNYXRoLnJvdW5kKC13aWR0aCArIHdpZHRoICogdGhpcy5jb3VudCAvIHRo +aXMuaWRzLmxlbmd0aCkgKyAicHggMHB4IjsKCiAgICAgICAgICAgICAgICAgICAgLy8gYW5kIHJ1 +biBhbm90aGVyIGJhdGNoCiAgICAgICAgICAgICAgICAgICAgdGhpcy5iYXRjaCsrOwogICAgICAg +ICAgICAgICAgICAgIHRoaXMucnVuQmF0Y2goKTsKICAgICAgICAgICAgICAgIH0KCiAgICAgICAg +ICAgICAgICAvLyBub3RoaW5nIHRvIHNob3cuLi4gCiAgICAgICAgICAgICAgICBpZiggdGhpcy5y +dW5zID09IDAgJiYgdGhpcy5jb3VudCA9PSAwICkKICAgICAgICAgICAgICAgIHsKICAgICAgICAg +ICAgICAgICAgICB2YXIgcE5vZGUgPSAkKCB0aGlzLnByZWZpeCArICdfcHJvZ3Jlc3NfYmFyJyAp +LnBhcmVudE5vZGU7CiAgICAgICAgICAgICAgICAgICAgJCh0aGlzLnByZWZpeCArICdfcHJvZ3Jl +c3NfYmFyJykucmVtb3ZlKCk7CiAgICAgICAgICAgICAgICAgICAgdmFyIHNwYW4gPSBuZXcgRWxl +bWVudCggJ3NwYW4nLCB7ICdjbGFzcyc6ICdlcF9yZWZfcmVwb3J0X2VtcHR5JyB9ICk7CiAgICAg +ICAgICAgICAgICAgICAgc3Bhbi51cGRhdGUoICdSZXBvcnQgZW1wdHknICk7CiAgICAgICAgICAg +ICAgICAgICAgcE5vZGUuaW5zZXJ0KCBzcGFuICk7CiAgICAgICAgICAgICAgICB9CiAgICAgICAg +ICAgICAgICB0aGlzLnJ1bnMrKzsKICAgICAgICAgICAgfSkuYmluZCh0aGlzKQogICAgICAgIH0p +OyAgICAgICAgCiAgICB9LAogICAgZXhlY3V0ZTogZnVuY3Rpb24oKSB7CiAgICAgICAgLy8gcHJv +Z3Jlc3MtYmFyCiAgICAgICAgdGhpcy5jb250YWluZXIuaW5zZXJ0KCBuZXcgRWxlbWVudCggJ2Rp +dicsIHsgJ2NsYXNzJzogJ2VwX3JlcG9ydF9wcm9ncmVzc19iYXInLCAnaWQnOiB0aGlzLnByZWZp +eCArICJfcHJvZ3Jlc3NfYmFyIiB9ICkgKTsgIAoKICAgICAgICB2YXIgY3VycmVudF9ncm91cGlu +ZyA9IG51bGw7ICAgIC8vIG1pZ2h0IG5vdCBiZSBzZXQgaW4gdGhlIHJldHVybmVkIHZhbHVlIGJ1 +dCB0aGF0J3MgYWxsb3dlZC9PSwogICAgICAgIHRoaXMubm9faXRlbXMgPSB0aGlzLmlkcy5sZW5n +dGg7CiAgICAgICAgdGhpcy5yZXRyaWV2ZWQgPSBbXTsKICAgICAgICBpZiggIWlzSW50ZWdlcih0 +aGlzLmlkc1swXSkgKSAvL2lkcyBoYXZlIGJlZW4gZ3JvdXBlZAogICAgICAgIHsgICAKICAgICAg +ICAgICAgdGhpcy5ncm91cGVkID0gdHJ1ZTsKICAgICAgICAgICAgdGhpcy5ncm91cGVkX2lkcyA9 +IHRoaXMuaWRzOwogICAgICAgICAgICB0aGlzLmlkcyA9IFtdOwogICAgICAgICAgICBmb3IoIHZh +ciBpID0gMDsgaSA8IHRoaXMuZ3JvdXBlZF9pZHMubGVuZ3RoOyBpKysgKQogICAgICAgICAgICB7 +CiAgICAgICAgICAgICAgICB0aGlzLmlkcyA9IHRoaXMuaWRzLmNvbmNhdCh0aGlzLmdyb3VwZWRf +aWRzW2ldLmxpc3QpOwogICAgICAgICAgICB9CiAgICAgICAgICAgIC8vdGhlIGdyb3VwaW5nIG1h +eSBoYXZlIGNyZWF0ZWQgZHVwbGljYXRlIHJlY29yZHMgKGkuZS4gYSByZWNvcmQgY2FuIGFwcGVh +ciBpbiBtb3JlIHRoYW4gb25lIGdyb3VwKSAtIGl0J3MgaGFuZHkgdG8gaGF2ZSBhbiBhcnJheSBv +ZiBhbGwgdGhlIHVuaXF1ZSByZWNvcmRzCiAgICAgICAgICAgIHRoaXMudW5pcXVlID0gdGhpcy5p +ZHMuZmlsdGVyKGZ1bmN0aW9uKGl0ZW0sIGksIGFyKXsgcmV0dXJuIGFyLmluZGV4T2YoaXRlbSkg +PT09IGk7IH0pOwogICAgICAgICAgICB0aGlzLm5vX2l0ZW1zID0gdGhpcy51bmlxdWUubGVuZ3Ro +OwogICAgICAgIH0KCiAgICAgICAgaWYoIHRoaXMuaWRzID09IG51bGwgfHwgdGhpcy5pZHMubGVu +Z3RoID09IDAgKQogICAgICAgIHsKICAgICAgICAgICAgdmFyIHBOb2RlID0gJCh0aGlzLnByZWZp +eCArICdfcHJvZ3Jlc3NfYmFyJykucGFyZW50Tm9kZTsKICAgICAgICAgICAgJCh0aGlzLnByZWZp +eCArICdfcHJvZ3Jlc3NfYmFyJykuaGlkZSgpOwogICAgICAgICAgICB2YXIgc3BhbiA9IG5ldyBF +bGVtZW50KCAnc3BhbicsIHsgJ2NsYXNzJzogJ2VwX3JlZl9yZXBvcnRfZW1wdHknIH0gKTsKICAg +ICAgICAgICAgc3Bhbi51cGRhdGUoICdSZXBvcnQgZW1wdHknICk7CiAgICAgICAgICAgIHBOb2Rl +Lmluc2VydCggc3BhbiApOwogICAgICAgIH0KICAgICAgICB0aGlzLnJ1bkJhdGNoKCk7CiAgICB9 +CgoKfSk7CgpmdW5jdGlvbiBncm91cF9yZXBvcnQoZ3JvdXApCnsKICAgIGRvY3VtZW50Lmdyb3Vw +X3JlcG9ydC5ncm91cC52YWx1ZSA9IGdyb3VwOwogICAgZG9jdW1lbnQuZ3JvdXBfcmVwb3J0LnN1 +Ym1pdCgpOwp9CgpmdW5jdGlvbiBzb3J0X3JlcG9ydChzb3J0KQp7CiAgICBkb2N1bWVudC5zb3J0 +X3JlcG9ydC5zb3J0LnZhbHVlID0gc29ydDsKICAgIGRvY3VtZW50LnNvcnRfcmVwb3J0LnN1Ym1p +dCgpOwp9CgpmdW5jdGlvbiBpc0ludGVnZXIobnVtKSB7CiAgcmV0dXJuIChudW0gXiAwKSA9PT0g +bnVtOwp9Cg== + document static/style/auto/reports.css - text/plain - 04cbc93d0515c56f56929cd6a16f5a44 + text/x-asm + ea07a35607af90bafc7aed4c77da1242 MD5 - 2151 + 2244 ZGl2LmVwX3JlcG9ydF9yb3cgewoJcGFkZGluZzogNXB4IDVweDsKCW1hcmdpbi1ib3R0b206IDVw eDsKfQoKZGl2LmVwX3JlcG9ydF9yb3dfcHJvYmxlbXMgewoJYm9yZGVyLWxlZnQ6IHNvbGlkIDdw eCAjQzQxRjFGOwp9CgpkaXYuZXBfcmVwb3J0X3Jvd19vayB7CiAgICAgICAgYm9yZGVyLWxlZnQ6 @@ -2413,9 +2603,11 @@ b3J0X29wdGlvbnMgdWwKewoJcGFkZGluZzogMCAxMHB4IDAgMDsKfQoKI2VwX3JlcG9ydF9leHBv cnRfY29udGVudF9pbm5lciAuc2VsZWN0X2J1dHRvbgp7CiAgICAgICAgZmxvYXQ6IHJpZ2h0Owp9 CgojY3VzdG9tX3JlcG9ydCAuZXBfc2VhcmNoX2J1dHRvbnMgPiBkaXYKewogICAgICAgIGRpc3Bs YXk6IGlubGluZS1ibG9jazsKfQoKI2N1c3RvbV9yZXBvcnQgLmVwX3NlYXJjaF9idXR0b25zIC5j -bGVhcl9idXR0b24KewogICAgICAgIG1hcmdpbi1sZWZ0OiAycHg7Cn0KCi8qIEhUTUwgUmVwb3J0 -cyAqLwphLmh0bWxfcmVwb3J0X3ByaW50ewoJdGV4dC1kZWNvcmF0aW9uOiBub25lOwkKfQoKYS5o -dG1sX3JlcG9ydF9wcmludDpob3ZlcnsKCWNvbG9yOiB3aGl0ZTsJCn0K +bGVhcl9idXR0b24KewogICAgICAgIG1hcmdpbi1sZWZ0OiAycHg7Cn0KCiNyZXBvcnRfc2VsZWN0 +X2xhYmVsLCAjZXhwb3J0X3NlbGVjdF9sYWJlbAp7CiAgICBmb250LXdlaWdodDogNzAwOwogICAg +bWFyZ2luLXJpZ2h0OiA1cHg7Cn0KCi8qIEhUTUwgUmVwb3J0cyAqLwphLmh0bWxfcmVwb3J0X3By +aW50ewoJdGV4dC1kZWNvcmF0aW9uOiBub25lOwkKfQoKYS5odG1sX3JlcG9ydF9wcmludDpob3Zl +cnsKCWNvbG9yOiB3aGl0ZTsJCn0K @@ -2427,6 +2619,7 @@ dG1sX3JlcG9ydF9wcmludDpob3ZlcnsKCWNvbG9yOiB3aGl0ZTsJCn0K + document static/images/epm/reports.png image/png 11fe836e11dc3075b829e17f64caf50d @@ -2870,7 +3063,7 @@ mCeqVAAAAABJRU5ErkJggg== coverimage - 3.3.2 + 3.4.4 diff --git a/reports.epmi b/reports.epmi index b5ccb2b..c37fbd3 100644 --- a/reports.epmi +++ b/reports.epmi @@ -6,6 +6,7 @@ + document epm/reports/cfg/cfg.d/z_example_reports.pl.off text/plain 73e01974ab33e9a4d7972141c820c7a2 @@ -13,13 +14,15 @@ 1439 + document epm/reports/cfg/cfg.d/z_reports.pl text/plain - 48c622ad150bea255ba6fbee7e37083b + e0c09c35dc9b17fa48a00ad0555653fc MD5 - 2869 + 2905 + document epm/reports/cfg/cfg.d/z_search_reports.pl text/plain d85eb82057d42ddbf451390ce314d0ff @@ -27,20 +30,23 @@ 1400 + document lang/en/phrases/reports.xml - text/xml - 9c23d9b3d22356d0ff30793364082dbb + application/xml + ea18f8beec4a6fdaa4c1d0e588b38b55 MD5 - 2685 + 2765 + document plugins/EPrints/Plugin/Export/Grid2.pm text/plain - 83d730999923d798d1acbb44c4a91667 + ce4f81455c6bb8b5c0977a5e18836984 MD5 - 10222 + 13974 + document plugins/EPrints/Plugin/Export/MultilineCSV2.pm text/plain ece09c3f7932a096c5cf14b6165a579d @@ -48,6 +54,7 @@ 2279 + document plugins/EPrints/Plugin/Export/Report.pm text/plain 4532f1d3111eede3fe6a4e8c66965895 @@ -55,13 +62,15 @@ 2556 + document plugins/EPrints/Plugin/Export/Report/CSV.pm text/plain - 9ca03f1aa33ed8390c18f29c2ed96d16 + 197a1e34988fac693a4f2825cfc823d0 MD5 - 1785 + 2084 + document plugins/EPrints/Plugin/Export/Report/CSV/Example.pm text/plain 0e433b1b61f549da00316e4971512570 @@ -69,6 +78,7 @@ 409 + document plugins/EPrints/Plugin/Export/Report/HTML.pm text/plain 8e2ca840f2fd1fa5983bcca0f96a7233 @@ -76,20 +86,23 @@ 5578 + document plugins/EPrints/Plugin/Export/Report/JSON.pm text/plain - 3786d272e437a488408e5825270e1609 + c4b031c985ca0de7c8263474b232be14 MD5 - 6648 + 6994 + document plugins/EPrints/Plugin/Screen/Report.pm text/plain - 8bbbeeeb1dc8030c24e7814866e90e62 + 3f96896809763ee15750ac37e2c1b899 MD5 - 44075 + 45813 + document plugins/EPrints/Plugin/Screen/Report/EPrint.pm text/plain d3e587ba8d8f55c66102969ef662e3cb @@ -97,6 +110,7 @@ 1961 + document plugins/EPrints/Plugin/Screen/Report/Example.pm text/plain 1c2d8c6ae6fc484e6bb1a93978ec88b9 @@ -104,6 +118,7 @@ 1893 + document plugins/EPrints/Plugin/Screen/Report/Example/Articles.pm text/plain 4c43aa504919a5484599af05f9b146b1 @@ -111,6 +126,7 @@ 499 + document plugins/EPrints/Plugin/Screen/Report/Example/ConferenceItems.pm text/plain 3c8b240f6728e37d91784edf2409a85c @@ -118,6 +134,7 @@ 516 + document plugins/EPrints/Plugin/Screen/Report/User.pm text/plain cf71f006233ea48a6206f5e186956798 @@ -125,6 +142,7 @@ 1873 + document static/images/epm/reports.png image/png 11fe836e11dc3075b829e17f64caf50d @@ -132,18 +150,20 @@ 24469 + document static/javascript/auto/reports.js text/plain - 46e3bc42410200895fcfe29085a1246e + 058ab00d3be58f69cb6f9f3e6d7625f9 MD5 - 12510 + 16024 + document static/style/auto/reports.css - text/plain - 04cbc93d0515c56f56929cd6a16f5a44 + text/x-asm + ea07a35607af90bafc7aed4c77da1242 MD5 - 2151 + 2244 text/plain @@ -154,6 +174,7 @@ + document static/images/epm/reports.png image/png 11fe836e11dc3075b829e17f64caf50d @@ -166,7 +187,7 @@ coverimage - 3.3.2 + 3.4.4