<HTML><HEAD><link type="text/css" href="../css/main_styles.css" rel="stylesheet"></HEAD>
<BODY><TITLE>%mqc_check_sheet_anomaly</TITLE><H1>%mqc_check_sheet_anomaly </H1><P CLASS="Paragraph">Classname: <B>%mqc_check_sheet_anomaly </B></P><P CLASS="Paragraph">Inherits from: <B><A href=..\checkmate\xug_base_checker.html>%ug_base_checker </A></B></P><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"> </PRE><PRE STYLE=\"text-align : left;\" CLASS=\"Code\">
<B>Description:</B>
    Check if the part file contains any anomaly sheet body according to the
    following steps:
    1. Get a single pull direction:
        Identify a single die pull line (line/datum axis) which resides on the
        specified layers or layer category. If more than one die pull line reside
        on the specified layers or layer category, the checker should fail and exit.
        If a single die pull line is found, then get the direction of the pull line and
        continue the checking.
        Identify a single CSYS (Coordinate System) which resides on the specified layers or layer
        category. If more than one CSYS reside on the specified layers or layer
        category, the checker should fail and exit. If a single CSYS is found,
        get the direction of the Z axis of the CSYS and continue to check.
        Identify whether the direction of the die pull line equals to the direction
        of the Z axis of the CSYS. If these two directions are not equal to
        each other, then the checker should fail and exit; otherwise, get a single
        pull direction and continue the checking.
    2. Get a draft angle value tolerance:
        If Angle_Type option is Degrees, get the angle tolerance directly from Angle_Value.
        If Angle_Type option is Expression, first find the expression from the part file.
        If the expression can not be found, the checker should fail and exit.
        If the expression is found, then get the angle tolerance from the expression value.
        If Angle_Type option is Half_Angle_of_Cone, identify a single cone feature which
        resides on the specified layers or layer category. If more than one cone feature
        reside on the specified layers or layer category, the checker should fail and exit.
        If a single cone feauture is found, get the half angle value of the cone feature
        as the angle tolerance, and then continue the checking.
    3. Get the facet model of the entity to be checked on the specified layers or layer
        category. Check whether the draft angle, which is 90 degrees decreased by the angle
        measured between the direction of the die pull line and the normal of each facet
        of the facet model, is less than the draft angle value tolerance. If the draft angle
        is less than the draft angle tolerance, then the entity is anomaly and the checker
        should fail.
Parameters:
    (Name)    Pull_Line_Type    - Single die pull line type. Can be:
                                                 Line
                                                 Datum_Axis
                                                 Default is Line.
    (List)    Pull_Line_Spec    - Filter option for pull line layer specification.
                                                A single Pull Line should reside in this layer.
                                                Its direction represent for the die pull direction.
                                                Default is: layers - {"1"}.
    (List)    CSYS_Spec         - Filter option for CSYS layer specification.
                                                a single CSYS should reside in this layer.
                                                The z axis of this CSYS should point at the direction of
                                                 the die pull line.
                                                Default is:  layers - {"1"}.
    (Name)    Angle_Type        - Draft angle type. Can be:
                                               Degrees
                                               Expression
                                               Half_Angle_of_Cone
                                  When the degrees option is selected, use Angle_Value
                                  as the draft angle.
                                  When the expression option is selected, use value of
                                  expression as the draft angle.
                                  When the half angle of cone option is selected, use half
                                  angle of cone as the draft angle.
                                  The draft angle is the maximum angle limit between the
                                  pull line direction and the facet normal.
                                  If the computed angle value is larger than the limit,
                                  then the sheet body has anomaly.
                                  Default is Degrees
    (Number)  Angle_Value       - Draft angle value.
                                  It is the maximum draft angle limit between the
                                  pull line direction and the facet normal.
                                  Default is 6 degrees.
    (Name)    Angle_Unit        - Unit of draft angle value. Can be:
                                            Degrees
                                            Radians
                                            Default is Degrees.
    (String)  Expression_Name   - Expression name representing the draft angle
                                  Default is ""
    (List)    Cone_Spec         - Filter option for Cone layer specification.
                                  a single Cone should reside in this layer.
                                  The half angle of this Cone is used as draft angle.
                                  Default is:  layers - {"1"}.
    (Name)  Facet_Quality       - Quality of the facet model. Can be:
                                           Coarse
                                           Normal
                                           Fine
                                           Extra_Fine
                                           Ultra_Fine
                                  The Facet_Quality option is used to determine the
                                  resolution of the Facet model of the sheet body.
                                  Default is Normal.
    (List)    Check_Spec        - Layer filter for sheet bodies to be validated.
                                          Default is: layers - {"1"}.
    (Boolean)  disabled?        - If it is true, the checker is disabled.
                                  Default is False.
    (Boolean)  save_log_in_part -  The flag indicates whether the checking results can
                                   be saved to the part file
                                   Default is True.
    (Name)    log_type          - Indicate which logging type to use to report the violation.
                                   Can be:
                                         LOG_ERROR
                                         LOG_WARNING
                                         LOG_INFO
                                    Default is LOG_ERROR.
    (String)  log_msg           - User specified additional error/warning/info message to be logged.
                                  Default is "".
Results:
    FAILED -  Case 1: There is neither one line nor datum axis residing on
                      the specified layer.
                      Case 2: There is no CSYS residing on the specified layer.
                      Case 3: Z axis of the CSYS is not pointing in the same direction
                      of the pull line.
                      Case 4: half_angle_of_cone is selected as Angle Type, but there is
                      not only one Cone residing on the specified layer.
                      Case 5: expression is selected as Angle Type, but an angle value
                      can not be evaluated from the Expression name.
                      Case 6: the draft angle is less than the draft angle tolerance.
    PASS   -    None of the above six cases occurs. All entities satisfy the draft angle
                      criterion.
</PRE><PRE><FONT COLOR= blue>DefClass: %mqc_check_sheet_anomaly( %ug_base_checker );
</FONT></PRE><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( String )               %test_category: "Template.DFM";
   ( String )               %displayed_name: "Check Sheet Body Anomaly";
</SPAN></FONT></PRE></DIV><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( Boolean Parameter )    Disabled?: False;
   ( Boolean Parameter )    save_log_in_part: True;
</SPAN></FONT></PRE></DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\">   Attributes for this class</PRE><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( List )                  Pull_Line_Type_option: {Line, Datum_Axis};
   ( String )                Pull_Line_Type_label: "Die Pull Line Type";

</SPAN></FONT></PRE></DIV><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( String )                Pull_Line_Spec_Label: "Layer Filter for Die Pull Line";
</SPAN></FONT></PRE></DIV><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( String )                CSYS_Spec_Label: "Layer Filter for CSYS";
</SPAN></FONT></PRE></DIV><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( List )                  Angle_Type_option: {Degrees, Expression,
                                                 Half_Angle_of_Cone};
   ( String )                Angle_Type_label: "Draft Angle Type";

</SPAN></FONT></PRE></DIV><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( String )                Angle_Value_label: "Draft Angle Value";

</SPAN></FONT></PRE></DIV><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( String )                Angle_Unit_label: "Draft Angle Unit";
   ( List )                  Angle_Unit_option: {Degrees, Radians};

</SPAN></FONT></PRE></DIV><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( String )                Expression_Name_label: "Draft Angle Expression Name";

</SPAN></FONT></PRE></DIV><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( String )                Cone_Spec_Label: "Layer Filter for Cone";
</SPAN></FONT></PRE></DIV><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( List )                  Facet_Quality_option: {Coarse, Normal, Fine,
                                                    Extra_Fine, Ultra_Fine};
   ( String )                Facet_Quality_label: "Facet Quality";

</SPAN></FONT></PRE></DIV><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( String )                Check_Spec_Label: "Layer Filter for Sheet Body";
</SPAN></FONT></PRE></DIV><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( List )                  log_type_option: { LOG_ERROR, LOG_WARNING, LOG_INFO, LOG_ANY };
   ( String )                log_type_label: "Log Option";

</SPAN></FONT></PRE></DIV><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( Name Parameter )        Pull_Line_Type: Line;
   ( List Parameter )        Pull_Line_Spec: {};
   ( Name Parameter )        Pull_Line_Spec_Layer_Mode: Include;
   ( List Parameter )        Pull_Line_Spec_Layer_Filter: {"1"};
   ( List Parameter )        CSYS_Spec: {};
   ( Name Parameter )        CSYS_Spec_Layer_Mode: Include;
   ( List Parameter )        CSYS_Spec_Layer_Filter: {"1"};
   ( Name Parameter )        Angle_Type: Degrees;
   ( Number Parameter )      Angle_Value: 6.0;
   ( Name Parameter )        Angle_Unit: Degrees;
   ( String Parameter )      Expression_Name: "";
   ( List Parameter )        Cone_Spec: {};
   ( Name Parameter )        Cone_Spec_Layer_Mode: Include;
   ( List Parameter )        Cone_Spec_Layer_Filter: {"1"};
   ( Name Parameter )        Facet_Quality: Normal;
   ( List Parameter )        Check_Spec: {};
   ( Name Parameter )        Check_Spec_Layer_Mode: Include;
   ( List Parameter )        Check_Spec_Layer_Filter: {"1"};
   ( Name Parameter )        log_type: LOG_ERROR;
   ( String Parameter )      log_msg: "";
</SPAN></FONT></PRE></DIV><DIV><PRE STYLE=\"text-align : left;\" CLASS=\"Code\"><FONT COLOR=blue>   ( String )                log_msg_label: "Additional Message";


   (Any Uncached)   do_check:
   @{
       #get the pull line check result.
       $pull_line_check_result <<
       @{
           #get the layer numbers on whick a single pull line should reside.
           $pull_line_layers << mqc_parse_layerSpecification ( Pull_Line_Spec_Layer_Filter: );

           If( empty?( $pull_line_layers ) )
           Then
               { 1, Vector(0,0,0), "Pull Line Layer is invalid.", {} }
           Else
           #a line.
           If ( Pull_Line_Type: = Line )
           Then
           @{
               #ask all lines on the specified layers.
               $line_in_layer << mqc_collectEntitiesWithFilterOptions(
                                    include, {line},
                                    Pull_Line_Spec_Layer_Mode:, Pull_Line_Spec_Layer_Filter:,
                                    include, {all});
               $line_num << Length( $line_in_layer );

               If ( $line_num = 1 )  Then
               @{
                   #OK, get the tag of the single line.
                   $single_line << nth ( 1, $line_in_layer );

                   $line_hp << %mqc_askHostpointerOfTag ( $single_line );
                   $line_start_point << ug_curve_askStartPoint ( $line_hp );
                   $line_end_point << ug_curve_askEndPoint( $line_hp );
                   $pull_line_vector << unitize( $line_end_point - $line_start_point );

                   { 0, $pull_line_vector, "OK", {$single_line} };
               }
               Else
               @{
                   $detail_msg <<
                       If( $line_num > 1)
                       Then
                           "Found "
                           + stringvalue( $line_num )
                           + " lines on the specified Pull Line Layer.~n"
                           + "There should be only one line on Pull Line Layer.~n"
                       Else
                           "Can not find any line on the specified Pull Line Layer.~n"
                           + "There should be one line on Pull Line Layer.~n";

                   { 1, Vector( 0,0,0), $detail_msg, $line_in_layer };
               };
           }
           #a datum axis.
           Else
           @{
               #ask all axises on the specified layers.
               $axis_in_layer << mqc_collectEntitiesWithFilterOptions(
                                    include, {datum_axis},
                                    Pull_Line_Spec_Layer_Mode:, Pull_Line_Spec_Layer_Filter:,
                                    include, {all});
               $axis_num << Length( $axis_in_layer );

               If ( $axis_num = 1 )
               Then
               @{
                   #OK, get the tag of the single datum axis.
                   $single_axis << nth ( 1, $axis_in_layer );

                   $datum_axis_feature << mqc_askFeatureOfEntity ( $single_axis );
                   $datum_axis_hp << %mqc_askHostpointerOfTag ( $datum_axis_feature );
                   $pull_line_vector << ug_datum_askAxisDir ( $datum_axis_hp );

                   { 0, $pull_line_vector, "OK", {$single_axis} };
               }
               Else
               @{
                   $detail_msg <<
                       If( $axis_num > 1)
                       Then
                            "Found "
                            + stringvalue( $axis_num )
                            + " datum axis on the specified Pull Line Layer.~n"
                            + "There should be only one datum axis on Pull Line Layer.~n"
                       Else
                            "Can not find any datum axis on Pull Line Layer.~n "
                            + "There should be one datum axis on Pull Line Layer.~n";

                   { 1, Vector( 0, 0, 0 ), $detail_msg, $axis_in_layer };
               };
           };
       };

       #get the csys check result.
       $CSYS_check_result <<
       @{
           #get the layer numbers on whick a single CSYS should reside.
           $CSYS_layers << mqc_parse_layerSpecification( CSYS_Spec_Layer_Filter: );

           If( empty?($CSYS_layers) )
           Then
               { 1, Vector(0,0,0), "CSYS Layer is invalid.", {} }
           Else
           @{
               #ask all entities of csys on the specified layers.
               $csys_in_layer << mqc_collectEntitiesWithFilterOptions(
                                    include, {csys},
                                    CSYS_Spec_Layer_Mode:, CSYS_Spec_Layer_Filter:,
                                    include, {all});
               $csys_num << Length( $csys_in_layer );

               If ( $csys_num = 1 )  Then
               @{
                   $single_csys << nth(1, $csys_in_layer);
                   $info_of_csys << mqc_askCsysInfo( $single_csys );
                   $pull_line_vector << nth(4, $info_of_csys);

                   { 0, $pull_line_vector, "OK", {$single_csys} };
               }
               Else
               @{
                   $detail_msg <<
                       If( $csys_num > 1)
                       Then
                           "Found "
                           + stringvalue( $csys_num )
                           + " CSYSes on the specified CSYS Layer.~n"
                           + "There should be only one CSYS on CSYS Layer.~n"
                       Else
                           "Can not find any CSYS on the specified CSYS Layer.~n"
                           + "There should be one CSYS on CSYS Layer.~n";

                   { 1, Vector( 0,0,0), $detail_msg, $csys_in_layer };
               };
           };
       };

       #check if the pull line vector equals to the Z axis of the single CSYS.
       $vector_check_result <<
           If( ( nth(1, $pull_line_check_result) = 0 )
               & ( nth(1, $CSYS_check_result) = 0 )
               & ( Angle2Vectors( nth (2, $pull_line_check_result),
                                  nth(2, $CSYS_check_result),
                                  nth (2, $pull_line_check_result) * nth(2, $CSYS_check_result) ) < 0.00001 ) )
           Then
               { 0, nth(2, $pull_line_check_result), "OK", {} }
           Else
               { 1, vector(0,0,0), "Can not get a single vector.", {} };

       #get the degree tolerence
       $degree_check_result <<
       @{
           #from the degree value
           If( Angle_Type: = Degrees ) Then
           @{
               $Angl << if(Angle_Unit: = Degrees )
                        Then Angle_Value:
                        Else Angle_Value:/M_pi:*180;

               { 0, $Angl, "OK", {} };
           }
           #from the expression
           Else If( Angle_Type: = Expression ) Then
           @{
               If( -member(Expression_Name:, mqc_askExpressions()) )
               Then
                   { 1, 0, "Expression <" + Expression_Name: + "> does not exist.~n", {} }
               Else
               @{
                   $measure_and_unit << mqc_askDimensionalityOfExpression(Expression_Name:);

                   If(length($measure_and_unit) != 2)
                   Then
                       { 1, 0, "Expression <" + Expression_Name: + "> does not have dimensionality.~n", {} }
                   Else
                   @{
                       If ( nth ( 1, $measure_and_unit ) = "Angle" )
                       Then
                           { 0, mqc_evalExpression( Expression_Name: ), "OK", {} }
                       Else
                           { 1, 0, "Expression <" + Expression_Name: + "> is not an angle.~n", {} };
                   };
               };
           }
           #from the cone's half-angle
           Else
           @{
               #get the layer numbers on whick a single cone should reside.
               $cone_layers << mqc_parse_layerSpecification( Cone_Spec_Layer_Filter: );

               If( empty?($cone_layers) )
               Then
                   { 1, 0, "Cone Layer is invalid.", {} }
               Else
               @{
                   $cone_feats << mqc_askFeatures( feature_type, CONE );

                   $solid_bodies_in_layers << mqc_collectEntitiesWithFilterOptions(
                                                include, {solid_body},
                                                Cone_Spec_Layer_Mode:, Cone_Spec_Layer_Filter:,
                                                include, {all});

                   $cone_feats_in_layers <<
                   Loop
                   {
                       For $each_cone in $cone_feats;
                       For $cone_body is mqc_askBodyOfFeature ( $each_cone );
                       If (member($cone_body, $solid_bodies_in_layers))
                           Append {$each_cone};
                   };

                   If ( length ( $cone_feats_in_layers ) = 1 )
                   Then
                       { 0, mqc_askHalfAngleOfCone( Nth ( 1, $cone_feats_in_layers )),
                       "OK", $cone_feats_in_layers }
                   Else If ( length ( $cone_feats_in_layers ) = 0  )
                   Then
                       { 1, 0, "Can not find any cone in the specified Cone Layer.~nThere should be one cone on Cone Layer.~n",
                         $cone_feats_in_layers}
                   Else
                       { 1, 0, "Found " + stringvalue(length ( $cone_feats_in_layers ))
                       + " cones in the specified Cone Layer.~nThere should be only one cone on Cone Layer.~n", $cone_feats_in_layers};
               };
           };
       };

       ##check entities anomalies
       $anomaly_check_result <<
       @{
           #Failed to get a single pull line vector or get a degree tolerence.
           If( nth(1, $vector_check_result) = 1  | nth(1, $degree_check_result) = 1 )
           Then
               {1, "Pull line is error or degree is error", {} }
           Else
           @{
               #get the layer numbers from Checked Layer
               $entities_layers << mqc_parse_layerSpecification( Check_Spec_Layer_Filter: );

               If( empty?($entities_layers) )
               Then
                   { 1, "The checked layer is invalid.", {} }
               Else
               @{
                   $pull_vector << nth(2, $vector_check_result);
                   $degree_tolerence << nth(2, $degree_check_result);

                   #get all entities of the specified type on the specify layer,
                   #whick will be checked for any anomalies.
                   $sheet_body_in_layer << mqc_collectEntitiesWithFilterOptions(
                                                include, {sheet_body},
                                                Check_Spec_Layer_Mode:, Check_Spec_Layer_Filter:,
                                                include, {all});

                   If( empty?($sheet_body_in_layer) )
                   Then
                       { 1, "No SHEET BODY resides on the checked layer.", {}}
                   Else
                   @{
                       #get all faces of the sheet bodies in list $sheet_body_in_layer
                       $faces_of_sheet_body << Loop
                       {
                           For $each_sheet_body in $sheet_body_in_layer;
                           For $sheet_body_hp   is %mqc_askHostpointerOfTag($each_sheet_body);
                           For $faces_hp        is ug_body_askFaces($sheet_body_hp);
                           For $faces_tag       is Loop
                           {
                               For $each_face_hp in $faces_hp;
                               Append { %mqc_askTagOfHostpointer($each_face_hp); };
                           };

                           Append $faces_tag;
                       };

                       $anom_entis<< Loop
                       {
                           #get topology of each entity
                           #then get facets of each topology
                           For $each_entity in $faces_of_sheet_body;
                           For $topology_ is mqc_askFacetModelOfEntity(
                                         $each_entity, facet_quality, Facet_Quality: );
                           For $Facets is mqc_askFacetsOfTopology($topology_);
                           For $anomaly_Facets is Loop
                           {
                               #get normals of each facet
                               For $each_facet in $Facets;
                               For $normals is
                                  mqc_askNormalsOfFacet($topology_,$each_facet);
                               For $anomaly_normals is
                               Loop
                               {
                                   For $each_normal in $normals;
                                   For $angl2Vect is angle2vectors( $each_normal,
                                      $pull_vector, $each_normal * $pull_vector);
                                   For $angl_mod is
                                       If ( $angl2Vect < 90 )
                                       Then $angl2Vect
                                       Else
                                       If( ($angl2Vect >= 90) & ($angl2Vect < 180) )
                                       Then 180 - $angl2Vect
                                       Else
                                       If( ($angl2Vect >= 180) & ($angl2Vect < 270) )
                                       Then $angl2Vect - 180
                                       Else 360 - $angl2Vect;
                                   For $angl_mod is 90 - $angl_mod;

                                   #if the draft angle is less than the draft angle tolerance
                                   If( $angl_mod <= $degree_tolerence )
                                        Append {$each_normal};
                               };
                               If( !Empty?( $anomaly_normals ) )
                                      Append {$each_facet};
                           };
                           If ( !Empty?( $anomaly_Facets ) )
                                  Append {$each_entity};
                       };

                       If( Empty?( $anom_entis ) )
                       Then
                           { 0, "OK", {} }
                       Else
                       @{
                           #Error, found anomaly entities
                           $detail_msg <<
                           If( Length($anom_entis) = 1)
                           Then
                               "Found one anomaly entity on the Checked Layer.~n"
                           Else
                               "Found "
                               + stringvalue(Length($anom_entis))
                               + " anomaly entities on the Checked Layer.~n";

                           { 1, $detail_msg, $anom_entis };
                       };
                   };
               };
           };
       };

       #Write log message, Log all failed cases.
       $usr_msg << If ( "" = log_msg: ) Then "" Else "~n"+log_msg:;

       #Failed: Case1 - can not get a single pull line vector.
       If( nth(1, $pull_line_check_result) = 1 ) Then
           ug_mqc_log( log_type:,
                       nth(4, $pull_line_check_result),
                       $usr_msg + nth(3, $pull_line_check_result) )

       #Failed: Case2 - can not get a single CSYS.
       Else If( nth(1, $CSYS_check_result) = 1) Then
           ug_mqc_log( log_type:,
                       nth(4, $CSYS_check_result),
                       $usr_msg + nth(3, $CSYS_check_result) )

       #Failed: Case3 - the Z axis of the CSYS is not pointing in the
       #direction of the pull line.
       Else If( nth(1, $vector_check_result) = 1) Then
           ug_mqc_log( log_type:,
                       nth(4, $vector_check_result),
                       $usr_msg + nth(3, $vector_check_result) )

       #Failed: Case4 - can not get a single cone.
       Else If( (nth(1, $degree_check_result) = 1) & (Angle_Type: = Half_Angle_of_Cone) ) Then
           ug_mqc_log( log_type:,
                       nth(4, $degree_check_result),
                       $usr_msg + nth(3, $degree_check_result) )

       #Failed: Case5 - can not get a degree tolerence.
       Else If( (nth(1, $degree_check_result) = 1) & (Angle_Type: = Expression) ) Then
           ug_mqc_log( log_type:,
                       nth(4, $degree_check_result),
                       $usr_msg + nth(3, $degree_check_result) )

       #Failed: Case6 - some entities has anomalies.
       Else If( nth(1, $anomaly_check_result) = 1 ) Then
           ug_mqc_log( log_type:,
                       nth(3, $anomaly_check_result),
                       $usr_msg + nth(2, $anomaly_check_result) )

       Else Donothing;
   };

</SPAN></FONT></PRE></DIV></TABLE><p class=EndLine>&nbsp;</p><p class=blank>&nbsp;</p></BODY></HTML>