# Bazaar merge directive format 2 (Bazaar 0.90) # revision_id: address@hidden # target_branch: file:///home/davr/code2/pdf/trunk/ # testament_sha1: 979aafe1e38f1cb576b89b774b3e9489b71c55b0 # timestamp: 2008-07-22 14:49:58 +0200 # base_revision_id: address@hidden # # Begin patch === modified file 'AUTHORS' --- AUTHORS 2008-07-09 14:07:58 +0000 +++ AUTHORS 2008-07-18 07:39:39 +0000 @@ -152,6 +152,10 @@ /torture/unit/base/types/pdf-i64-neg.c /torture/unit/base/types/pdf-i64-abs.c /torture/unit/base/types/pdf-i64-cmp.c + /torture/unit/base/types/pdf-i64-mult.c + /torture/unit/base/types/pdf-i64-div.c + /torture/unit/base/types/pdf-i64-mod.c + /torture/unit/base/types/pdf-i64-subtraction.c and changed src/Makefile.am src/base/pdf-types.h src/base/pdf-types.c === modified file 'ChangeLog' --- ChangeLog 2008-07-20 22:06:45 +0000 +++ ChangeLog 2008-07-22 12:38:12 +0000 @@ -1,3 +1,23 @@ +2008-07-22 Daniel Vidal + + * src/base/pdf-types.c: Fixed negative number handling in some functions. Also error handling issues fixed. + + * torture/unit/base/types/pdf-i64-subtraction.c: Test for pdf_i64_subtraction function + + * torture/unit/base/types/pdf-i64-mod.c: Test for pdf_i64_mod function + + * torture/unit/base/types/pdf-i64-div.c: Test for pdf_i64_div function + + * torture/unit/base/types/pdf-i64-mult.c: Test for pdf_i64_mult function + + * torture/unit/base/types/tsuite-types.c: Added new tests + + * torture/unit/Makefile.am: Added new types tests + + * doc/gnupdf.texi: Changed i64 interfaces + + * doc/gnupdf-tsd.texi: Added new i64 tests + 2008-07-21 Jose E. Marchesi * doc/gnupdf-manual-wiki.init (mediawiki_preformatted): Fix a bug === modified file 'doc/gnupdf-tsd.texi' --- doc/gnupdf-tsd.texi 2008-06-24 16:13:30 +0000 +++ doc/gnupdf-tsd.texi 2008-07-18 07:47:14 +0000 @@ -4483,6 +4483,116 @@ @end table @end deffn address@hidden pdf_i64_mult address@hidden pdf_i64_mult + + address@hidden Test pdf_i64_mult_001 +Multiplies two positive numbers address@hidden @strong address@hidden Success condition +The call should not produce an error. address@hidden table address@hidden deffn + address@hidden Test pdf_i64_mult_002 +Checks if function checks the proper initialisation of target address@hidden @strong address@hidden Success condition +The call should produce an error address@hidden table address@hidden deffn + address@hidden Test pdf_i64_mult_003 + Mults a positive and negative number address@hidden @strong address@hidden Success condition +The call should not produce an error address@hidden table address@hidden deffn + address@hidden Test pdf_i64_mult_004 + Mults two negative numbers address@hidden @strong address@hidden Success condition +The call should not produce an error address@hidden table address@hidden deffn + + address@hidden pdf_i64_div address@hidden pdf_i64_div + + address@hidden Test pdf_i64_div_001 +Divides two positive numbers address@hidden @strong address@hidden Success condition +The call should not produce an error. address@hidden table address@hidden deffn + address@hidden Test pdf_i64_div_002 +Checks if function checks the proper initialisation of target address@hidden @strong address@hidden Success condition +The call should produce an error address@hidden table address@hidden deffn + address@hidden Test pdf_i64_div_003 + Divs a positive and negative number address@hidden @strong address@hidden Success condition +The call should not produce an error address@hidden table address@hidden deffn + address@hidden Test pdf_i64_div_004 + Divs two negative numbers address@hidden @strong address@hidden Success condition +The call should not produce an error address@hidden table address@hidden deffn + + address@hidden pdf_i64_mod address@hidden pdf_i64_mod + address@hidden Test pdf_i64_mod_001 +Mods two positive numbers address@hidden @strong address@hidden Success condition +The call should not produce an error. address@hidden table address@hidden deffn + address@hidden Test pdf_i64_mod_002 +Checks if function checks the proper initialisation of target address@hidden @strong address@hidden Success condition +The call should produce an error address@hidden table address@hidden deffn + address@hidden Test pdf_i64_mod_003 + Mods a positive and negative number address@hidden @strong address@hidden Success condition +The call should not produce an error address@hidden table address@hidden deffn + address@hidden Test pdf_i64_mod_004 + Mods two negative numbers address@hidden @strong address@hidden Success condition +The call should not produce an error address@hidden table address@hidden deffn + + @node Subsystem Testing @chapter Subsystem Testing === modified file 'doc/gnupdf.texi' --- doc/gnupdf.texi 2008-07-10 16:17:18 +0000 +++ doc/gnupdf.texi 2008-07-18 07:41:04 +0000 @@ -1,5 +1,5 @@ \input texinfo address@hidden $Id: gnupdf.texi,v 1.80 2008/07/10 14:17:19 aleksander_m Exp $ address@hidden $Id: gnupdf.texi,v 1.79 2008/07/07 20:22:31 jemarch Exp $ @comment %**start of header @setfilename gnupdf.info @settitle GNU PDF Library Reference @@ -479,7 +479,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_assign (pdf_i64_t address@hidden, const pdf_i32_t @var{high}, const pdf_u32_t @var{low}) address@hidden void pdf_i64_assign (pdf_i64_t address@hidden, const pdf_i32_t @var{high}, const pdf_u32_t @var{low}, pdf_status_t address@hidden) Assign a value coming from one 32 bit signed integer and a 32 bit unsigned integer to a i64 integer. @@ -503,11 +503,12 @@ @example pdf_i64_t *bignum; pdf_i64_t result; - +pdf_status_t *p_status; result = pdf_i64_new(0, 0); bignum = &result; -if (pdf_i64_assign(bignum, (32 << 1), 10) != PDF_OK) /*bignum is now -10*/ +pdf_i64_assign(bignum, (32 << 1), 10, p_status); +if (*p_status != PDF_OK) /*bignum is now -10*/ @{ /* Error code */ @} @@ -515,7 +516,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_assign_quick (pdf_i64_t address@hidden, const pdf_i32_t @var{value}) address@hidden void pdf_i64_assign_quick (pdf_i64_t address@hidden, const pdf_i32_t @var{value}, pdf_status_t address@hidden) Assign a value coming from one 32 bit signed integer to a i64 integer. @@ -537,10 +538,11 @@ @example pdf_i64_t *bignum; pdf_i64_t result; - +pdf_status_t *p_status; result = pdf_i64_new(0, 0); bignum = &result; -if (pdf_i64_assign_quick(bignum, -10) != PDF_OK) /*bignum is now -10*/ +pdf_i64_assign_quick(bignum, -10, p_status); +if (*p_status != PDF_OK) /*bignum is now -10*/ @{ /* Error code */ @} @@ -548,7 +550,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_copy (const pdf_i64_t @var{orig}, pdf_i64_t address@hidden) address@hidden void pdf_i64_copy (const pdf_i64_t @var{orig}, pdf_i64_t address@hidden, pdf_status_t address@hidden) Copies the data from orig to copy. @@ -570,9 +572,10 @@ @example pdf_i64_t orig; pdf_i64_t *copy; - +pdf_status_t *p_status; orig = pdf_i64_new(0, 10); -if (pdf_i64_copy(orig, copy) != PDF_OK) /*Now copy is also 10*/ +pdf_i64_copy(orig, copy,p_status) +if ( *p_status != PDF_OK) /*Now copy is also 10*/ @{ /* Error code */ @} @@ -580,7 +583,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_add (pdf_i64_t address@hidden, const pdf_i64_t @var{addend1}, const pdf_i64_t @var{addend2}) address@hidden void pdf_i64_add (pdf_i64_t address@hidden, const pdf_i64_t @var{addend1}, const pdf_i64_t @var{addend2}, pdf_status_t address@hidden) Adds two 64 bit numbers @@ -606,13 +609,13 @@ pdf_i64_t result; pdf_i64_t addend_1; pdf_i64_t addend_2; - +pdf_status_t *p_status; addend_1 = pdf_i64_new(0, 25); addend_2 = pdf_i64_new(0, 35); result = pdf_i64_new(0, 0); dest = &result; - -if (pdf_i64_add (dest, addend_1, addend_2) != PDF_OK) /* Now dest is 60 */ +pdf_i64_add (dest, addend_1, addend_2,p_status); +if (*p_status != PDF_OK) /* Now dest is 60 */ @{ /* Error code */ @} @@ -620,7 +623,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_add_i32 (pdf_i64_t address@hidden, const pdf_i64_t @var{addend1}, const pdf_i32_t @var{addend2}) address@hidden void pdf_i64_add_i32 (pdf_i64_t address@hidden, const pdf_i64_t @var{addend1}, const pdf_i32_t @var{addend2}, pdf_status_t address@hidden) Adds a 64bit number and a 32bit number. @@ -645,12 +648,12 @@ pdf_i64_t *dest; pdf_i64_t result; pdf_i64_t addend_1; - +pdf_status_t *p_status; addend_1 = pdf_i64_new(0, 25); result = pdf_i64_new(0, 0); dest = &result; - -if (pdf_i64_add (dest, addend_1, 35) != PDF_OK) /* Now dest is 60 */ +pdf_i64_add (dest, addend_1, 35,p_status) +if (*p_status != PDF_OK) /* Now dest is 60 */ @{ /* Error code */ @} @@ -659,7 +662,7 @@ @end deftypefun address@hidden pdf_status_t pdf_i64_subtraction (pdf_i64_t address@hidden, const pdf_i64_t @var{minuend}, const pdf_i64_t @var{subtrahend}) address@hidden void pdf_i64_subtraction (pdf_i64_t address@hidden, const pdf_i64_t @var{minuend}, const pdf_i64_t @var{subtrahend}, pdf_status_t address@hidden) Finds the difference between two 64 bit numbers @@ -685,13 +688,13 @@ pdf_i64_t result; pdf_i64_t minuend; pdf_i64_t subtrahend; - +pdf_status_t *p_status; minuend = pdf_i64_new(0, 25); subtrahend = pdf_i64_new(0, 35); result = pdf_i64_new(0, 0); dest = &result; - -if (pdf_i64_subtraction (dest, minuend, subtrahend) != PDF_OK) /* Now dest is -10 */ +pdf_i64_subtraction (dest, minuend, subtrahend,p_status) +if (*p_status != PDF_OK) /* Now dest is -10 */ @{ /* Error code */ @} @@ -699,7 +702,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_subtraction_i32_min (pdf_i64_t address@hidden, const pdf_i32_t @var{minuend}, const pdf_i64_t @var{subtrahend}) address@hidden void pdf_i64_subtraction_i32_min (pdf_i64_t address@hidden, const pdf_i32_t @var{minuend}, const pdf_i64_t @var{subtrahend}, pdf_status_t address@hidden) Finds the difference between a 32bit number and a 64bit number @@ -724,12 +727,12 @@ pdf_i64_t *dest; pdf_i64_t result; pdf_i64_t subtrahend; - +pdf_status_t *p_status; subtrahend = pdf_i64_new(0, 35); result = pdf_i64_new(0, 0); dest = &result; - -if (pdf_i64_subtraction (dest, 25, subtrahend) != PDF_OK) /* Now dest is -10 */ +pdf_i64_subtraction (dest, 25, subtrahend,p_status) +if (*p_status != PDF_OK) /* Now dest is -10 */ @{ /* Error code */ @} @@ -738,7 +741,7 @@ @end deftypefun address@hidden pdf_status_t pdf_i64_subtraction_i32_sub (pdf_i64_t address@hidden, const pdf_i64_t @var{minuend}, const pdf_i32_t @var{subtrahend}) address@hidden void pdf_i64_subtraction_i32_sub (pdf_i64_t address@hidden, const pdf_i64_t @var{minuend}, const pdf_i32_t @var{subtrahend}, pdf_status_t address@hidden) Finds the difference between a 64bit number and a 32bit number @@ -763,12 +766,12 @@ pdf_i64_t *dest; pdf_i64_t result; pdf_i64_t minuend; - +pdf_status_t *p_status; minuend = pdf_i64_new(0, 25); result = pdf_i64_new(0, 0); dest = &result; - -if (pdf_i64_subtraction (dest, minuend, 35) != PDF_OK) /* Now dest is -10 */ +pdf_i64_subtraction (dest, minuend, 35,p_status); +if ( != PDF_OK) /* Now dest is -10 */ @{ /* Error code */ @} @@ -777,7 +780,7 @@ @end deftypefun address@hidden pdf_status_t pdf_i64_mult (pdf_i64_t address@hidden, const pdf_i64_t @var{factor_1}, const pdf_i64_t @var{factor_2}) address@hidden void pdf_i64_mult (pdf_i64_t address@hidden, const pdf_i64_t @var{factor_1}, const pdf_i64_t @var{factor_2}, pdf_status_t address@hidden) Multiplication of two 64 bit numbers @@ -803,13 +806,13 @@ pdf_i64_t result; pdf_i64_t factor_1; pdf_i64_t factor_2; - +pdf_status_t *p_status; factor_1 = pdf_i64_new (0, 10); factor_2 = pdf_i64_new (0, 100); result = pdf_i64_new (0, 0); dest = &result; - -if (pdf_i64_mult (dest, factor_1, factor_2) != PDF_OK) /* Now dest is 1000 */ +pdf_i64_mult (dest, factor_1, factor_2,p_status); +if ( *p_status != PDF_OK) /* Now dest is 1000 */ @{ /* Error code */ @} @@ -817,7 +820,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_mult_i32 (pdf_i64_t address@hidden, const pdf_i64_t @var{factor_1}, const pdf_i32_t @var{factor_2}) address@hidden void pdf_i64_mult_i32 (pdf_i64_t address@hidden, const pdf_i64_t @var{factor_1}, const pdf_i32_t @var{factor_2}, pdf_status_t address@hidden) Multiplication of a 64bit number and a 32bit number @@ -846,8 +849,8 @@ factor_1 = pdf_i64_new (0, 10); result = pdf_i64_new (0, 0); dest = &result; - -if (pdf_i64_mult (dest, factor_1, 100) != PDF_OK) /* Now dest is 1000 */ +pdf_i64_mult (dest, factor_1, 100,p_status) +if (*p_status != PDF_OK) /* Now dest is 1000 */ @{ /* Error code */ @} @@ -855,7 +858,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_div (pdf_i64_t address@hidden, const pdf_i64_t @var{dividend}, const pdf_i64_t @var{divisor}) address@hidden void pdf_i64_div (pdf_i64_t address@hidden, const pdf_i64_t @var{dividend}, const pdf_i64_t @var{divisor}, pdf_status_t address@hidden) Division of two 64 bit numbers @@ -882,8 +885,8 @@ divisor = pdf_i64_new(0, 10); result = pdf_i64_new(0, 0); dest = &result; - -if (pdf_i64_div (dest, dividend, divisor) != PDF_OK) /* Now dest is 20 */ +pdf_i64_div (dest, dividend, divisor,p_status); +if(*p_status != PDF_OK) /* Now dest is 20 */ @{ /* Error code */ @} @@ -891,7 +894,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_div_i32_dividend (pdf_i64_t address@hidden, const pdf_i32_t @var{dividend}, const pdf_i64_t @var{divisor}) address@hidden void pdf_i64_div_i32_dividend (pdf_i64_t address@hidden, const pdf_i32_t @var{dividend}, const pdf_i64_t @var{divisor}, pdf_status_t address@hidden) Division of a 32bit number and a 64bit number @@ -925,7 +928,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_div_i32_divisor (pdf_i64_t address@hidden, const pdf_i64_t @var{dividend}, const pdf_i32_t @var{divisor}) address@hidden void pdf_i64_div_i32_divisor (pdf_i64_t address@hidden, const pdf_i64_t @var{dividend}, const pdf_i32_t @var{divisor}, pdf_status_t address@hidden) Division of a 64bit number and a 32bit number @@ -960,7 +963,7 @@ @end deftypefun address@hidden pdf_status_t pdf_i64_mod (pdf_i64_t address@hidden, const pdf_i64_t @var{dividend}, const pdf_i64_t @var{divisor}) address@hidden void pdf_i64_mod (pdf_i64_t address@hidden, const pdf_i64_t @var{dividend}, const pdf_i64_t @var{divisor}, pdf_status_t address@hidden) Returns the remainder of the division between two 64 bit numbers @@ -986,13 +989,13 @@ pdf_i64_t result; pdf_i64_t dividend; pdf_i64_t divisor; - +pdf_status_t *p_status; dividend = pdf_i64_new(0, 105); divisor = pdf_i64_new(0, 10); result = pdf_i64_new(0, 0); dest = &result; - -if (pdf_i64_mod (dest, dividend, divisor) != PDF_OK) /* Now dest is 5 */ +pdf_i64_mod (dest, dividend, divisor,p_status); +if ( *p_status != PDF_OK) /* Now dest is 5 */ @{ /* Error code */ @} @@ -1000,7 +1003,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_mod_i32_dividend (pdf_i64_t address@hidden, const pdf_i32_t @var{dividend}, const pdf_i64_t @var{divisor}) address@hidden void pdf_i64_mod_i32_dividend (pdf_i64_t address@hidden, const pdf_i32_t @var{dividend}, const pdf_i64_t @var{divisor}, pdf_status_t address@hidden) Returns the remainder of the division between a 32bit number and a 64bit number @@ -1038,7 +1041,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_mod_i32_divisor (pdf_i64_t address@hidden, const pdf_i64_t @var{dividend}, const pdf_i32_t @var{divisor}) address@hidden void pdf_i64_mod_i32_divisor (pdf_i64_t address@hidden, const pdf_i64_t @var{dividend}, const pdf_i32_t @var{divisor}, pdf_status_t address@hidden) Returns the remainder of the division between a 64bit number and a 32bit number @@ -1076,7 +1079,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_abs (pdf_i64_t address@hidden, const pdf_i64_t @var{number}) address@hidden void pdf_i64_abs (pdf_i64_t address@hidden, const pdf_i64_t @var{number}, pdf_status_t address@hidden) Returns the absolute value @@ -1099,12 +1102,12 @@ pdf_i64_t *dest; pdf_i65_t result; pdf_i64_t number; - +pdf_status_t *p_status; number = pdf_i64_new ((32 << 1), 105); /*number is -105*/ result = pdf_i64_new (0, 0); dest = &result; - -if (pdf_i64_abs (dest, number) != PDF_OK) /* now dest stores 105 */ +pdf_i64_abs (dest, number,p_status) +if ( *p_status != PDF_OK) /* now dest stores 105 */ @{ /* Error code */ @} @@ -1180,7 +1183,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_i64_neg (pdf_i64_t address@hidden, const pdf_i64_t @var{number}) address@hidden void pdf_i64_neg (pdf_i64_t address@hidden, const pdf_i64_t @var{number}, pdf_status_t address@hidden) Changes sign of 64 bit integer @@ -1201,12 +1204,12 @@ pdf_i64_t *dest; pdf_i65_t result; pdf_i64_t number; - +pdf_status_t *p_status; number = pdf_i64_new (0, 10); result = pdf_i64_new (0, 0); dest = &result; - -if (pdf_i64_neg (dest, number) != PDF_OK) /* now dest stores -10 */ +pdf_i64_neg (dest, number,p_status) +if ( *p_status != PDF_OK) /* now dest stores -10 */ @{ /* Error code */ @} @@ -4986,7 +4989,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_time_get_utc_cal (const pdf_time_t @var{time_var}, struct pdf_time_cal_s address@hidden) address@hidden pdf_status_t pdf_time_get_utc_cal (const pdf_time_t @var{time_var}, struct pdf_time_cal_s address@hidden) Get the UTC calendar time of a given time variable. @table @strong @@ -4995,7 +4998,7 @@ @table @var @item time_var A properly created time variable. address@hidden p_utc_time address@hidden p_cal_time A pointer to the calendar time structure that will hold the UTC time of @var{time_var}. @end table @@ -5520,7 +5523,7 @@ @end table @end deftypefun address@hidden pdf_status_t pdf_time_span_negate (pdf_time_span_t address@hidden) address@hidden pdf_status_t pdf_time_span_negate (pdf_time_span_t @var{span}) Make a positive time span into a negative one or make a negative time span into a positive one. @@ -5529,8 +5532,8 @@ @item Parameters @table @var address@hidden p_span -Pointer to a properly created time span variable. address@hidden span +A properly created time span variable. @end table @item Returns @@ -5659,7 +5662,7 @@ @end table @end deftypefun address@hidden pdf_i64_t pdf_time_span_to_secs (const pdf_time_span_t @var{span}) address@hidden pdf_64_t pdf_time_span_to_secs (const pdf_time_span_t @var{span}) Get the value of a time span in seconds. === modified file 'src/base/pdf-types.c' --- src/base/pdf-types.c 2008-07-09 14:05:48 +0000 +++ src/base/pdf-types.c 2008-07-18 07:42:30 +0000 @@ -189,6 +189,7 @@ if (dest == NULL) { *p_status = PDF_ERROR; + return; } if (number.high < 0) @@ -216,6 +217,7 @@ if (dest == NULL) { *p_status = PDF_ERROR; + return; } pdf_i64_t tempo, one; @@ -237,6 +239,7 @@ if (dest == NULL) { *p_status = PDF_ERROR; + return; } pdf_i64_t neg_subtrahend; @@ -349,17 +352,18 @@ if (dest == NULL) { *p_status = PDF_ERROR; + return; } /*Now check the signs of multiplier and multiplicand*/ pdf_i64_assign(&zero,0,0, p_status); - if (pdf_i64_cmp(multiplier,zero) < 0) + if (pdf_i64_cmp(factor_1,zero) < 0) { result_sign = -1; pdf_i64_abs(&multiplier,multiplier, p_status); } - if (pdf_i64_cmp(multiplicand,zero) < 0) + if (pdf_i64_cmp(factor_2,zero) < 0) { pdf_i64_abs(&multiplicand,multiplicand, p_status); if (result_sign == -1) @@ -547,12 +551,14 @@ if (dest == NULL) { *p_status = PDF_ERROR; + return; } /*Check first if divisor != 0*/ if (pdf_i64_cmp(zero,divisor) == 0) { *p_status = PDF_ERROR; + return; } /*Now check the signs fo divisor and dividend*/ if (pdf_i64_cmp(divisor,zero) < 0) @@ -777,6 +783,7 @@ if (dest == NULL) { *p_status = PDF_ERROR; + return; } else { @@ -829,12 +836,14 @@ if (dest == NULL) { *p_status = PDF_ERROR; + return; } /*Check first if divisor != 0*/ if (pdf_i64_cmp(zero,divisor) == 0) { *p_status = PDF_ERROR; + return; } /*Now check the signs fo divisor and dividend*/ if (pdf_i64_cmp(divisor,zero) < 0) @@ -847,7 +856,7 @@ pdf_i64_abs(÷nd,dividend, p_status); if (result_sign == -1) { - result_sign = 1; + result_sign = -1; } else { @@ -1034,13 +1043,24 @@ } - pdf_i64_assign(dest,0,0, p_status); - pdf_i64_div(dest,temp,d_pdf, p_status); - - + + + if (result_sign == -1) + { + pdf_i64_t temp_sign; + pdf_i64_assign(&temp_sign,0,0, p_status); + pdf_i64_div(&temp_sign,temp,d_pdf, p_status); + pdf_i64_neg(dest, temp_sign, p_status); + } + else + { + pdf_i64_assign(dest,0,0, p_status); + pdf_i64_div(dest,temp,d_pdf, p_status); + } if (dest == NULL) { *p_status = PDF_ERROR; + return; } else { === modified file 'torture/unit/Makefile.am' --- torture/unit/Makefile.am 2008-06-24 14:10:26 +0000 +++ torture/unit/Makefile.am 2008-07-18 07:43:15 +0000 @@ -145,7 +145,11 @@ base/types/pdf-i64-add.c \ base/types/pdf-i64-abs.c \ base/types/pdf-i64-neg.c \ - base/types/pdf-i64-cmp.c + base/types/pdf-i64-cmp.c \ + base/types/pdf-i64-mult.c \ + base/types/pdf-i64-div.c \ + base/types/pdf-i64-mod.c \ + base/types/pdf-i64-subtraction.c TEST_ENVIRONMENT = CHARSETALIASDIR=$(top_srcdir)/lib === added file 'torture/unit/base/types/pdf-i64-div.c' --- torture/unit/base/types/pdf-i64-div.c 1970-01-01 00:00:00 +0000 +++ torture/unit/base/types/pdf-i64-div.c 2008-07-18 07:45:04 +0000 @@ -0,0 +1,177 @@ +/* -*- mode: C -*- Time-stamp: "danividal" + * + * File: pdf-i64-div.c + * Date: Mon May 05 10:30:01 2008 + * + * GNU PDF Library - Types Module - pdf_i64_div test case + * + */ + +/* Copyright (C) 2008 Free Software Foundation, Inc. */ + +/* This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include +#include +#include + + + +#define INTERACTIVE_DEBUG 0 + +/* + * Test: pdf_i64_div_001 + * Description: + * Checks if the division of two positive numbers + * is carried out properly + * Success conditions: + * The call should not produce an error + */ +START_TEST(pdf_i64_div_001) +{ + pdf_status_t p_status = PDF_OK; + pdf_i64_t div1,div2,dest; + div1 = pdf_i64_new(0,8); + div2 = pdf_i64_new(0,2); + + + +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + pdf_i64_div(&dest,div1,div2, &p_status); + fail_if(p_status != PDF_OK); + fail_if(dest.low != 4); + fail_if(dest.high != 0); +#else + pdf_i64_div(&dest,div1,div2, &p_status); + fail_if(dest != 4); +#endif + +} +END_TEST + + +/* + * Test: pdf_i64_div_002 + * Description: + * Checks if function checks the proper initialisation of target + * Success conditions: + * The call should produce an error + */ + +START_TEST(pdf_i64_div_002) +{ + pdf_status_t p_status = PDF_OK; + pdf_i64_t div1,div2; + + div1 = pdf_i64_new(0,4); + div2 = pdf_i64_new(5,0); + + + +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + pdf_i64_t *dest = NULL; + pdf_i64_div(dest,div1,div2, &p_status); + fail_if(p_status != PDF_ERROR); +#endif + + +} +END_TEST + +/* + * Test: pdf_i64_div_003 + * Description: + * Divs a positive and negative number + * Success conditions: + * The call should not produce an error + */ +START_TEST(pdf_i64_div_003) +{ + pdf_status_t p_status = PDF_OK; + pdf_i64_t div1, div2, dest; + +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + div1 = pdf_i64_new(0xFFFFFFFF,0xFFFFFFFA); /*-6*/ + div2 = pdf_i64_new(0,3); + pdf_i64_div(&dest, div1, div2, &p_status); + + fail_if(p_status != PDF_OK); + + fail_if(dest.low != 0xFFFFFFFE); /*-2*/ + fail_if(dest.high != 0xFFFFFFFF); +#else + div1 = -6; + div2 = 3; + pdf_i64_div(&dest, div1, div2, &p_status); + fail_if(dest != -2); +#endif + + +} +END_TEST + + + +/* + * Test: pdf_i64_div_004 + * Description: + * Divs two negative numbers + * Success conditions: + * The call should not produce an error + */ +START_TEST(pdf_i64_div_004) +{ + + pdf_i64_t div1, div2, dest; + pdf_status_t p_status = PDF_OK; +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + div1 = pdf_i64_new(0xFFFFFFFF,0xFFFFFFFA); /*-6*/ + div2 = pdf_i64_new(0xFFFFFFFF,0xFFFFFFFE); /*-2*/ + + pdf_i64_div(&dest, div1, div2, &p_status); + + fail_if(p_status != PDF_OK); + + fail_if(dest.low != 3); + fail_if(dest.high != 0); +#else + div1 = -6; + div2 = -2; + pdf_i64_div(&dest, div1, div2, &p_status); + fail_if(dest != 3); +#endif + +} +END_TEST + + + +/* + * Test case creation function + */ +TCase * +test_pdf_i64_div (void) +{ + TCase *tc = tcase_create("pdf_i64_div"); + tcase_add_test(tc, pdf_i64_div_001); + tcase_add_test(tc, pdf_i64_div_002); + tcase_add_test(tc, pdf_i64_div_003); + tcase_add_test(tc, pdf_i64_div_004); + return tc; +} + +/* End of pdf-i64-div.c */ === added file 'torture/unit/base/types/pdf-i64-mod.c' --- torture/unit/base/types/pdf-i64-mod.c 1970-01-01 00:00:00 +0000 +++ torture/unit/base/types/pdf-i64-mod.c 2008-07-18 07:45:04 +0000 @@ -0,0 +1,177 @@ +/* -*- mode: C -*- Time-stamp: "danividal" + * + * File: pdf-i64-mod.c + * Date: Mon May 05 10:30:01 2008 + * + * GNU PDF Library - Types Module - pdf_i64_mod test case + * + */ + +/* Copyright (C) 2008 Free Software Foundation, Inc. */ + +/* This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include +#include +#include + + + +#define INTERACTIVE_DEBUG 0 + +/* + * Test: pdf_i64_mod_001 + * Description: + * Checks if the modulus of two positive numbers + * is carried out properly + * Success conditions: + * The call should not produce an error + */ +START_TEST(pdf_i64_mod_001) +{ + pdf_status_t p_status = PDF_OK; + pdf_i64_t mod1,mod2,dest; + mod1 = pdf_i64_new(0,7); + mod2 = pdf_i64_new(0,2); + + + +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + pdf_i64_mod(&dest,mod1,mod2, &p_status); + fail_if(p_status != PDF_OK); + fail_if(dest.low != 1); + fail_if(dest.high != 0); +#else + pdf_i64_mod(&dest,mod1,mod2, &p_status); + fail_if(dest != 1); +#endif + +} +END_TEST + + +/* + * Test: pdf_i64_mod_002 + * Description: + * Checks if function checks the proper initialisation of target + * Success conditions: + * The call should produce an error + */ + +START_TEST(pdf_i64_mod_002) +{ + pdf_status_t p_status = PDF_OK; + pdf_i64_t mod1,mod2; + + mod1 = pdf_i64_new(0,4); + mod2 = pdf_i64_new(5,0); + + + +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + pdf_i64_t *dest = NULL; + pdf_i64_mod(dest,mod1,mod2, &p_status); + fail_if(p_status != PDF_ERROR); +#endif + + +} +END_TEST + +/* + * Test: pdf_i64_mod_003 + * Description: + * Mods a positive and negative number + * Success conditions: + * The call should not produce an error + */ +START_TEST(pdf_i64_mod_003) +{ + pdf_status_t p_status = PDF_OK; + pdf_i64_t mod1, mod2, dest; + +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + mod1 = pdf_i64_new(0xFFFFFFFF,0xFFFFFFFB); /*-5*/ + mod2 = pdf_i64_new(0,3); + pdf_i64_mod(&dest, mod1, mod2, &p_status); + + fail_if(p_status != PDF_OK); + + fail_if(dest.low != 0xFFFFFFFE); + fail_if(dest.high != 0xFFFFFFFF); +#else + mod1 = -5; + mod2 = 3; + pdf_i64_mod(&dest, mod1, mod2, &p_status); + fail_if(dest != -2); +#endif + + +} +END_TEST + + + +/* + * Test: pdf_i64_mod_004 + * Description: + * Mods two negative numbers + * Success conditions: + * The call should not produce an error + */ +START_TEST(pdf_i64_mod_004) +{ + + pdf_i64_t mod1, mod2, dest; + pdf_status_t p_status = PDF_OK; +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + mod1 = pdf_i64_new(0xFFFFFFFF,0xFFFFFFFB); /*-5*/ + mod2 = pdf_i64_new(0xFFFFFFFF,0xFFFFFFFD); /*-3*/ + + pdf_i64_mod(&dest, mod1, mod2, &p_status); + + fail_if(p_status != PDF_OK); + + fail_if(dest.low != 0xFFFFFFFE); + fail_if(dest.high != 0xFFFFFFFF); +#else + mod1 = -5; + mod2 = -3; + pdf_i64_mod(&dest, mod1, mod2, &p_status); + fail_if(dest != -2); +#endif + +} +END_TEST + + + +/* + * Test case creation function + */ +TCase * +test_pdf_i64_mod (void) +{ + TCase *tc = tcase_create("pdf_i64_mod"); + tcase_add_test(tc, pdf_i64_mod_001); + tcase_add_test(tc, pdf_i64_mod_002); + tcase_add_test(tc, pdf_i64_mod_003); + tcase_add_test(tc, pdf_i64_mod_004); + return tc; +} + +/* End of pdf-i64-mod.c */ === added file 'torture/unit/base/types/pdf-i64-mult.c' --- torture/unit/base/types/pdf-i64-mult.c 1970-01-01 00:00:00 +0000 +++ torture/unit/base/types/pdf-i64-mult.c 2008-07-18 07:45:04 +0000 @@ -0,0 +1,177 @@ +/* -*- mode: C -*- Time-stamp: "danividal" + * + * File: pdf-i64-mult.c + * Date: Mon May 05 10:30:01 2008 + * + * GNU PDF Library - Types Module - pdf_i64_mult test case + * + */ + +/* Copyright (C) 2008 Free Software Foundation, Inc. */ + +/* This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include +#include +#include + + + +#define INTERACTIVE_DEBUG 0 + +/* + * Test: pdf_i64_mult_001 + * Description: + * Checks if the multiplication of two positive numbers + * is carried out properly + * Success conditions: + * The call should not produce an error + */ +START_TEST(pdf_i64_mult_001) +{ + pdf_status_t p_status = PDF_OK; + pdf_i64_t mult1,mult2,dest; + mult1 = pdf_i64_new(0,2); + mult2 = pdf_i64_new(0,2); + + + +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + pdf_i64_mult(&dest,mult1,mult2, &p_status); + fail_if(p_status != PDF_OK); + fail_if(dest.low != 4); + fail_if(dest.high != 0); +#else + pdf_i64_mult(&dest,mult1,mult2, &p_status); + fail_if(dest != 4); +#endif + +} +END_TEST + + +/* + * Test: pdf_i64_mult_002 + * Description: + * Checks if function checks the proper initialisation of target + * Success conditions: + * The call should produce an error + */ + +START_TEST(pdf_i64_mult_002) +{ + pdf_status_t p_status = PDF_OK; + pdf_i64_t mult1,mult2; + + mult1 = pdf_i64_new(0,4); + mult2 = pdf_i64_new(5,0); + + + +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + pdf_i64_t *dest = NULL; + pdf_i64_mult(dest,mult1,mult2, &p_status); + fail_if(p_status != PDF_ERROR); +#endif + + +} +END_TEST + +/* + * Test: pdf_i64_mult_003 + * Description: + * Mults a positive and negative number + * Success conditions: + * The call should not produce an error + */ +START_TEST(pdf_i64_mult_003) +{ + pdf_status_t p_status = PDF_OK; + pdf_i64_t mult1, mult2, dest; + +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + mult1 = pdf_i64_new(0xFFFFFFFF,0xFFFFFFFE); /*-2*/ + mult2 = pdf_i64_new(0,3); + pdf_i64_mult(&dest, mult1, mult2, &p_status); + + fail_if(p_status != PDF_OK); + + fail_if(dest.low != 0xFFFFFFFA); /*-6*/ + fail_if(dest.high != 0xFFFFFFFF); +#else + mult1 = -2; + mult2 = 3; + pdf_i64_mult(&dest, mult1, mult2, &p_status); + fail_if(dest != -6); +#endif + + +} +END_TEST + + + +/* + * Test: pdf_i64_mult_004 + * Description: + * Mults two negative numbers + * Success conditions: + * The call should not produce an error + */ +START_TEST(pdf_i64_mult_004) +{ + + pdf_i64_t mult1, mult2, dest; + pdf_status_t p_status = PDF_OK; +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + mult1 = pdf_i64_new(0xFFFFFFFF,0xFFFFFFFE); /*-2*/ + mult2 = pdf_i64_new(0xFFFFFFFF,0xFFFFFFFE); /*-2*/ + + pdf_i64_mult(&dest, mult1, mult2, &p_status); + + fail_if(p_status != PDF_OK); + + fail_if(dest.low != 4); + fail_if(dest.high != 0); +#else + mult1 = -2; + mult2 = -2; + pdf_i64_mult(&dest, mult1, mult2, &p_status); + fail_if(dest != 4); +#endif + +} +END_TEST + + + +/* + * Test case creation function + */ +TCase * +test_pdf_i64_mult (void) +{ + TCase *tc = tcase_create("pdf_i64_mult"); + tcase_add_test(tc, pdf_i64_mult_001); + tcase_add_test(tc, pdf_i64_mult_002); + tcase_add_test(tc, pdf_i64_mult_003); + tcase_add_test(tc, pdf_i64_mult_004); + return tc; +} + +/* End of pdf-i64-mult.c */ === added file 'torture/unit/base/types/pdf-i64-subtraction.c' --- torture/unit/base/types/pdf-i64-subtraction.c 1970-01-01 00:00:00 +0000 +++ torture/unit/base/types/pdf-i64-subtraction.c 2008-07-18 07:45:04 +0000 @@ -0,0 +1,179 @@ +/* -*- mode: C -*- Time-stamp: "" + * + * File: pdf-i64-subtraction.c + * Date: Mon May 05 10:30:01 2008 + * + * GNU PDF Library - Types Module - pdf_i64_subtraction test case + * + */ + +/* Copyright (C) 2008 Free Software Foundation, Inc. */ + +/* This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +#include +#include +#include +#include +#include + + + +#define INTERACTIVE_DEBUG 0 + +/* + * Test: pdf_i64_subtraction_001 + * Description: + * Subtracts two positive numbers + * Success conditions: + * The call should not produce an error + */ +START_TEST(pdf_i64_subtraction_001) +{ + pdf_status_t p_status = PDF_OK; + pdf_i64_t subtraction1,subtraction2,dest; + subtraction1 = pdf_i64_new(0,5); + subtraction2 = pdf_i64_new(0,3); + + + + + + +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + pdf_i64_subtraction(&dest,subtraction1,subtraction2, &p_status); + fail_if(p_status != PDF_OK); + fail_if(dest.low != 2); + fail_if(dest.high != 0); +#else + pdf_i64_subtraction(&dest,subtraction1,subtraction2, &p_status); + fail_if(dest != 2); +#endif + +} +END_TEST + + +/* + * Test: pdf_i64_subtraction_002 + * Description: + * Checks if function checks the proper initialisation of target + * Success conditions: + * The call should produce an error + */ + +START_TEST(pdf_i64_subtraction_002) +{ + pdf_status_t p_status = PDF_OK; + pdf_i64_t subtraction1,subtraction2; + + subtraction1 = pdf_i64_new(0,4); + subtraction2 = pdf_i64_new(5,0); + + + +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + pdf_i64_t *dest = NULL; + pdf_i64_subtraction(dest,subtraction1,subtraction2, &p_status); + fail_if(p_status != PDF_ERROR); +#endif + + +} +END_TEST + +/* + * Test: pdf_i64_subtraction_003 + * Description: + * Subtracts a positive and negative number + * Success conditions: + * The call should not produce an error + */ +START_TEST(pdf_i64_subtraction_003) +{ + pdf_status_t p_status = PDF_OK; + pdf_i64_t subtraction1, subtraction2, dest; + +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + subtraction1 = pdf_i64_new(0xFFFFFFFF,0xFFFFFFFE); /*-2*/ + subtraction2 = pdf_i64_new(0,3); + pdf_i64_subtraction(&dest, subtraction1, subtraction2, &p_status); + + fail_if(p_status != PDF_OK); + + fail_if(dest.low != 0xFFFFFFFB); /*-5*/ + fail_if(dest.high != 0xFFFFFFFF); +#else + subtraction1 = -2; + subtraction2 = 3; + pdf_i64_subtraction(&dest, subtraction1, subtraction2, &p_status); + fail_if(dest != -5); +#endif + + +} +END_TEST + + + +/* + * Test: pdf_i64_subtraction_004 + * Description: + * Subtractions two negative numbers + * Success conditions: + * The call should not produce an error + */ +START_TEST(pdf_i64_subtraction_004) +{ + + pdf_i64_t subtraction1, subtraction2, dest; + pdf_status_t p_status = PDF_OK; +#ifndef PDF_USE_BUILTIN_64BIT_SUPPORT + subtraction1 = pdf_i64_new(0xFFFFFFFF,0xFFFFFFFE); /*-2*/ + subtraction2 = pdf_i64_new(0xFFFFFFFF,0xFFFFFFFD); /*-3*/ + + pdf_i64_subtraction(&dest, subtraction1, subtraction2, &p_status); + + fail_if(p_status != PDF_OK); + + fail_if(dest.low != 1); + fail_if(dest.high != 0); +#else + subtraction1 = -2; + subtraction2 = -3; + pdf_i64_subtraction(&dest, subtraction1, subtraction2, &p_status); + fail_if(dest != 1); +#endif + +} +END_TEST + + + +/* + * Test case creation function + */ +TCase * +test_pdf_i64_subtraction (void) +{ + TCase *tc = tcase_create("pdf_i64_subtraction"); + tcase_add_test(tc, pdf_i64_subtraction_001); + tcase_add_test(tc, pdf_i64_subtraction_002); + tcase_add_test(tc, pdf_i64_subtraction_003); + tcase_add_test(tc, pdf_i64_subtraction_004); + return tc; +} + +/* End of pdf-i64-subtraction.c */ === modified file 'torture/unit/base/types/tsuite-types.c' --- torture/unit/base/types/tsuite-types.c 2008-06-24 14:10:26 +0000 +++ torture/unit/base/types/tsuite-types.c 2008-07-18 07:43:15 +0000 @@ -33,6 +33,10 @@ extern TCase *test_pdf_i64_abs (void); extern TCase *test_pdf_i64_neg (void); extern TCase *test_pdf_i64_cmp (void); +extern TCase *test_pdf_i64_mult (void); +extern TCase *test_pdf_i64_div (void); +extern TCase *test_pdf_i64_mod (void); +extern TCase *test_pdf_i64_subtraction (void); Suite * tsuite_types () @@ -49,6 +53,10 @@ suite_add_tcase (s, test_pdf_i64_abs()); suite_add_tcase (s, test_pdf_i64_neg()); suite_add_tcase (s, test_pdf_i64_cmp()); + suite_add_tcase (s, test_pdf_i64_mult()); + suite_add_tcase (s, test_pdf_i64_div()); + suite_add_tcase (s, test_pdf_i64_mod()); + suite_add_tcase (s, test_pdf_i64_subtraction()); return s; } # Begin bundle IyBCYXphYXIgcmV2aXNpb24gYnVuZGxlIHY0CiMKQlpoOTFBWSZTWeHCe1MAHunfgF4wfff//3/v 36S////6YCgffe+feyoxseibiXAAtuh95i++75Guvb27oGu7u2Gz1uoFVEUa22gKo0Zuz1oAA5Ou 2KKKABSgeQAAAZUFAUoVQpxmUU9A0AChVDw1U9TJoGjQ00GIAGg0aNGjQ0AAAAyCUIaAgECNCmRo jyIyNA0NGgAANACSNFEam0mBUeUP1J4pk09R6g9QAAAAABoM0kJohGqP1R6nlDIDQ2poNGmgNAGg 0ADQIkomFNCn6aZTI09TTU8U2Sep6m1PUyPU9NNTagaZNNAAFSRAIIAAjRMCNGRkjJNpNNMoyMI8 psp6ZRMyPsFFQoVBQsVpFpJPD9s7rqd+BdEeP4PuqpRU3pVqNodQFt1B/H72l5fyIOoP+CVpCIBh qvKZmZmZlh5AgPD24bpfj3a8z8I4MWqS679vr67Y6El6/E5BtJN3Lw27QstCNBD++Klm0hF50hUk kkkqqqSEJIoSDZry/vPZf8n8w4PIlzOfOCVFfqrR8WgvbtSXiviytH+QdxR6Omx1rDfcukxqUdPZ eeepXIjwaVcwtMCH1I7AmlVSRCe4pISYlqphFCHdFIpjpFx2tFQqqKhVUodVBIoYMJVMyUMGFqVM VTWoPrOJ4jM3nxHdaez/pKPp531cABEp6pckvHnsSSSIPVS3pNuChmfMzHIYGges4caqq6CTrqqq qiqPUUUSiePnlieTyxE6pNbLSKExFQtYlRHKTfONKpVP+SYdeT0e71dnbNUVGTl5a0a99sJvOMdu Oa+unOriLRLQ9YAx6pqiqiqiqJoCMIBRUERDsYXM0UC6PXCwbSkGeEhyctZq1gHlrSyMoVgxFbMy lrPQeaqKFrIs4VzOmLXLs0LTXK3PimA7LZprZJ7U31JYIyMyeckV3WFvKiye5iveVSxSLqpRRVOy WJGCSXKiwiiNCeQqJ74qZYH6z+kzOPL0XbcSxRU0KiiBGAKZYCH+B4U5VoIkokIR2B9EL4Rqf1x4 j2knuiVc5z3aZeXrnszXe3LzbmH/Wi3Zb3NrX2/pltu+vdRrrpmq9+wjEqSQdx5Fj0+yFWDRDfSR 3RRNB0lH7zrPRmeJ37BDhU4VY/KKb4dwZxzjJFCSSQ1QCosiJIq9hiu7tBRhF/kUcPLjuWg6cuLp Ibm7L183Pd8leUtuA91SjucyRmvRPZkxO5XWaWtCU2PjUnCdKwCFHLxizCJC2o+IuHYKVtKGTWyp OEbQylR3d6NmpGaK4rSats7OWWspyo3QN9YGJ1hgUyFgKlrs7tii5vCFgzS0SzYkhUm4w66Ky4j5 9brfujUlU7DJJmYNSxRL643l9kQ0NDYhqUaR64xpauGiyQhoLcQemttMS4QQ82QoslmsHaq1WvLY fzA1RQDfMiKKKCh1nKFpeoqRRRRoY5EykH+59x8JPVUeibyipQV6qqx9v1n/BlluHWUTM/5JYwPM fkcxMDI5jLhVdJa1V5zGH8TcXSR8A6T5E0Nwqf1JqFjeWOZLEsI/iM5H9DuMDmPkc8nTMC3Akr3W kzPOWOMbjM1MCT+xrNBhxklyTdJJb4/1L/bqZxMZGAuZnu4JgbFksMabyi+6E+Da0zMZiRM4nZsW MU/H5DiMTXbLoq8ayauLLs9JYwKsrmTjNyMTDH6LFpNFuI3w46zvRo1OgyPdmdDbVLGJZLJ4HA1o wTAxLJZMN8aChpDqkok5zlcGcNFJNDtzOmS5mfAvauJoPIJpxqARRJaIGYUkITEbJn22ROk7MzMz M0ws5mc5bznMkkkkws5mVnLec5kkkkmF2UFZs85M8qqqqsVXM4igshQaryeBdC3BYrJJIGYHXWnx 2BYF4aMUzI5oqlUqlUqlUU3niYkmmho57dbe03JRYslhRwJuk0Lh0GOWh4aXzxO/f4ZWucqJqOBw iaimUnWew10DNHNlIzm7LgbjduFIYGB4n4HaXOhA3zj9fn+BFVC7VAW5Sc5DKkI76AigADQAcAWQ 0jswoqFWWBHQOgqmPVRIG14LqtF9i4X5l7rvwvHJrKy5zb751xkU5aaZ3vieeRLN2y642jc8fgp5 ensERE10rprrWGoHuAqgiZIqIT9RUT/E+8DBgJ6xYhZy2TecxvMDmLrrry9Wtf25Se0kqihlwtMC VI8+Geel75Cfkz+Nws/EKkjMKH+B0KgPTv1ROwZh6S+JmZmZmb+gifQHocB2B55BRKV+eUtSFnnI LRJpjR+WIYB2XcYhAdkZLuywwbbbqqqq4fYwGiVpcCPta99Li+DenPEhvxLxPvvqR+8iglFSigoo VChJRRO0IFFFBBOoCxXZzSZBTOxDMWzM0FiI3MDdZJCMICecLQXpNzPvzR4QsLN9ZPZoMDBKZMiy 9JSUUlPeerDmWp8g2kMiqM005r95Yza4eYlw9rgYTWKlRUqPse7cz2Z41Wczitvxvj+R1lFE1+qH tfefQvY70QOB8fASmqS7aa6E5fAR724nZdK4qd/P4sGMYvNGGZ1QjAUgsUm/lTenWFmZxKNlRD4J KrUKFwk3ljsA6w6EiBzzyJvRjE+g4TolOswkxJsmcYVTSTau5A7xXwC4fUHNG6h7Q7BDS2g2S+es s0MvL5dVVoDiXzTXVVFXdUEklFFKqoowWxd4d4cQ84DUGADvA260YSE1IAdIdLIyMjIDvoCgoIfQ Hr9ICIcBcx3GBIYjx8PIZmZmZmLWsWta1rWtbNVO/nPT+8alDaSZsD8sBMwsq0ku4PBYdXhNW+58 UdbZC6x6BCuElMKKmdKUhjTChLUddTGj6qqkxttoMH7SpNJZSn3BhsjHO7UZz+smFJJapI1WTAlK QHBWUngVDlfLXPivDGS+lhyTUqKTlLPQycnB3k0G6hrLd6zFWElUOEk0JddZTJuG7DmOFrycjWTB NJTi1zyf4M8603lTLe4MV+rDmluA1JRpKKRESwqMIUKOZGgwgAQmfg4rWdhmNDgKDqVFSTfS29TB N7lbMnKyYPuxXaPFvXG6R7FNZTWQ8DzrfpcTeN0gQhIETeBm3nuai467BWEIEc8rfwpQQAtjig40 RAY5TLwcolJ1p756zQ9pBWaA0EUgQIv10EgoD1a4YFKnnm5KyTcm5MIvF4vGGLTQ4WsuqjY1Os1v WkTSHBEC5meUQaAK08Zx3KQcUlWixqSPM+9UoSkUjy5IkQ8wIiTIDojdlbbPLOOexu2m+laPPFAM jZE2UChs0iW7YQNCqCGpFT6pmCJsaZ66ohPgyCZAgkG4MhkgGXCuiYFDaHBemSgo4u7YhtgEEOLm lVW5H0+ORcvM9BfNjzv7I05ZOmI53U5nSs4OaHawb20Lu1dgYEGRRTA1ZoO8Dp8yIy2Fhu07Wo2M 13wixXIk2YZ9MXgS8tE6R4YUY6Lwp8uWvk5bbbbbmKoqVpjfzLZL0HwIlVDS1Wuu0koJRCqCqpw5 bbbbbbexda2HOLXkbY29AGYJgdqiRRJ58DWHevtdrnfz3lr9breZedU0ZZpmqWDldCnUXNbVTMRg MzBKRY9IkTZtHC6Bohe6Wcia3NTCa4TOt7abLzRktGCs1NWKzCWd5Ek6HqKjFjBYcpU1ExFVCBvs MIYMo7ZFERzNhETtHt2yE2QC5QyNzMY5Ch8jRJ667noUJHkdUzDME2O52ylJE613ZGZkSD69qM79 XhTV4TKUCLlrQUPKSgwNEoEEsVpaYzoENwlTwvGEy0bIh4zMwPIv77jGSFg65RJoJ2VN8jY2g+mc ROZgnksBRhOp4ExIqLVTgXqWJEBhrJgvaN8lauDVdbnHHnpVYVbyd2/rkx2TYuFaxtEEYNjcpLYE kMMOf+CnZUXcwbnIY4XU6WD+6cHBk52jxM2LJgzT3vgUmM9UO4GBPl08DY568EkSDaKvVUYOHdvA XrReghe6LSs9ranlulLFWmULyTSSoURW+2W6+mO9ZTwaPBUR3OeRnlrWK0K0YK8fG7rbMXaKmnWq Hu63Vrw4MpHDyyHHDPO9x1LdIdLHbqziJseZSuZXjYJjxtVAhTAHdPMfLMHG1FCJmaHIlimQmWhd HAMIIYBEAOpuMUIkjYwcuXIsYNiUlW5hxeWBeDB2GOD7Ig5scyndETD5nB3qPhDuTkk4dvG62ThH WVfHsLYaY5VdFnKbB0eMGViTzgCzr2V6x6gGjP57Bn8AVLIg9sjRs2iiJoiQJjHHtRByOzo6JAme O1xxiY2KlUQiVKjO40SZKE6eRCRMO52IzNiQQuuom48EO1PIWsxeYyRRHIy3lc189kmN5XVwaSY0 GFKkZzp1o5MaxQUpNcLKiCbJ0GNjzNxXFq5G5dvZM2LMwfFOdxXbOZg8ZFoen4Ayxz3boXCts3ee N3E3jnwgu3hVScAYSsDENyTngjgtbEaKsiUI1XAzsRunIbBC+TzRJlD4kEOGm3XdzvcGSRJKqLKH HPm3u5bbmVyvK1d+RQ5DXnrWvBCEOw4bnwpSBTueWUdg6jgxlMfqZQQHo9rOUVcgROxQsXOZgwdT gsSJkCQwc+arAwVOBhxjgPWCXTnrryTdulrZSRFUjsyyXnZYPC0b+uQEwexUgIJHDTscFsIEgdQy VEBBjgBhCnS/UzaK8DGcJgmRB7NKSAyggygA0zEXJUURGLxUXCK3IbMs1Jly51Hi5QW5eNMR0gRL 1y6SKlUQyQRMipoYJm5d2MF2rgcrNgxdCbm50NHFg4KasHonH2gnGS3C15qckFyposEfnCMo2jKD 1CGsJdJJWCpdJphrQ1YWk3VJCZyEWre5FXxTfbmaM2m4kMSJnvPfFFotyZAz4ODp02S5Ox3DCiLA 6isQY2NB585a0MxRycRyY5WNOBdBprQiWGMAK+otiRwe5EscypyLG5YYkMcuTlzvqcixB2pHXwQe IF2GWRXQRC0dNyPa3cXvxd1WMarTidRCYJScW22c6EwMD7DF8iteRR5jWSanb00EPAgpFE1NigJ2 NYMOKbFcDxIGQ5uVIYwLmLnnnjscGhK5U0MryNhoLZm2IkjBqYLnBsmLJysGLicFjBHu7QoNhv/A 9Ut3VWBfmwTb4BiZnTE66jfQqpyxVo6gncBvsUIRCEnSEYCSv3UGQbdpCcTMSCYC2lLA0xisO+yj Tc6VFLqPlP5qlJL3vdb9CYmBWK0EuUjnKiP8zEOl8+HCp7vjb8AwFDIlRKKEoofkKgFAfoHrqmAS EhBSBEgQVgI6O4d61KlFHALWlEqKPwFeN6sLWgbkMGDEMSGDBAlKUaGhoG9Oy/ae0fqkWCh9Y5hZ gNBcL7CiwvJgK5USZioN5JGxLSSj80KEqQqRb/af5n8D+ZRieR/c//mQcMZ3Kj/Pacm8KpUJVVVC q/ie8P4H7QrQ/ccpkf9HEnGZcaN0qTg3HIgf2DCZjEsGVFof6n+hhBsf2NjUuDIP7msf8INSiD+C C4ukk3HG6H/BRLlE/3NofwMQwLh3mx4GQYH88h/dEYmh1lFBgR4yjr9SxyUdlH/Rax5g4HgbFH8w xLFw+q8PBEdB5z6vIijFILBc5wuHSbFHAxKKMTAuYQWI8xjcxDEhyBuDSRGYZhkWDzlBkYi5kDHi ZnWHeXGRQYBmhNIUVKDAO4jIsbBxNwcDjuGlIMQ3gSB9np93a25mW22NuZmZltttttuZltttttuZ ltt+NkIiFiAfTxBHlikbB9QUFg9yegik/Xb5Lli5JFoh+ZffxrkquRwiAxxqXkiyyypLJ+II0K5s MRELoAGJeDYpz8+PtyeYkkkKpSOQqJvLCJwCUhv3oTZCgSY4IAQIEhiB7kKYIk7JpCe9JMuCy+sc NKmbs6yHabdtmdE9RETAuO4yFHafmuUVJdzMGDVizXXZKYKczJ/Fk0P9+dm/k5VnW6BP5etycFcr oZrmzunZK8SQtCn+kOtuE/od80b+03LM3iG0g3ETmOv1ENxXc3lNzAGywSx9m6BQLtJ4rwPYwI0i N5OzIkzLbCjMYROTyD2SMkYmJk/2dHPDvJgkTfJyXOE1LwhqXHxJR9RFEeKbch/kWD/33nOV7Cjp k10AXAG0Iidfp1wyAKnkQ1B0+/X4PAetfcW26MXueaHrc7FeZNGizF8He2fWwXYLOWGbBZk3N5m1 fY1dHt0ZL9TyqqVSqlUbOZs+D7T4LMzZyNzykTF0vr/R9T7msJ4BzjI5bS1BTYC0CBpD8nmR6kU+ ERGuILwbI8NunEPwYk+R8VzJ1PQ9UPSw23d7ufg6GxdZset63ph6XoatHBqwb31N7Z0w6o5ySNzg 4m9PuPCSGZRRHbm6nSzPacDreYk7oUSYy+S/l7eRobyNJ2EnS4utvOHiKGnP7Zxn/ovJ8JjwqHGI 1I63q5Yd8/vsQ3FEntpSmdRVe38IXLx8Q393BHIlSUvKILRUjuT2fUrsVitaZC9USrPkWFxULRFi 06ULyXJhhJ35+asKoZjJMlxvjHA8mLFPZUj3W2282jIOB51rtXtehMVj0tw9rtbLJqkYuRTVq5Ik yZDi9PVzLtXBd+fVJI5w1nJZ/ysRxYxHAd/GcY/lsPEkj/8PayimUpYqylirEKSFEKWBRCglEKCU wpnA+JDaM6z4OXqeDCc7JzLxFZv0heT0kdc0aO9uYGS0OgOonrJ/YqI9s7jKSkyM6t7SfeGKlP+h BgEIEISEhIQRoNTAnvklj5RI9ikIj9kNgtEcp8jpMzEk9KWqJ90eKrk3yiVKUwIs3pVlLJhDsKMz 0MTcIuT6dD7YPyKPiTlsFjtHMUSxPuGRNSjEfIk+MmhgSUZFs4lzcuNimUkbS0ljUxudRc+o4fOu ymxujUtN6cZUTHGQ4pM2x8x8JeJn9a8Tz+78xM5HxHtPUSGPH7UDM0JjBqeGuPr06bb8TlDh/kX5 16tjQzMzwTUYHNzccU7jHYiVHTLuLpWe94nMXPA/SHkKOyI6w5ZJpJVUbVeXOsMaK2iYJJZNnI6X b4uMOdvZODrYPqZGkRxO4scf1U7+ctdyyeiVhVi7R6Gbg3GBRP4ni0UzmoYw0czkToYifnFQm49U R3kXnrNTkR38kjoTH5E6UnlCk7DZ8hPvsruWkzCl6KXn+pOc5CPLshsJUSO6HTJsanAwX9H1yMBf rJafp26lxm6ZJNUm8Ygs4uC5zL2b+u0k3FQe24fuDIk5wzDif5ItCiUsFIFgoliXFItJN07hYsku 5C0kHOIvEj9pnDk3h9hQewLWk/aWLwqQvKlRE3RI6Hk+D1PU6mS6ynvetZue97VNGbV2rLvsMlma zFo+CzJspvSSQ7J2vp961rLETJm5nMpwGo51+Zk+5ztIjkczndMRvE7+A+kPE/OJjHmidCSxT7vr HETcFaYxJ0+CWN7xJtEWUfgKiMEjwmkO2SbjyuTJQ/DaXx9M99SpgmosZmJcsdg7YltIOibPQGEp JM7QqT6awd7rRaG6RR8h+RZPx/YrqtapXZDoJ+Q/dDPZ1PsJ6/qMMKopVVcWsVjPwdA+blIzh96I 5j98vSk3FyiPkSUkb99V6cjNFSaHfGZ724n27hgd0k+pHEu1BRg6D3njE0NwNvIAD9a4fM+MQyiY KNKKvlAuDv3rNj8QoDjRoAgVm4gJ4xHWVT3qedRvkzmhZpItuD1BzROWJWxEvEfmAgY4hwA0E0o8 42cz4gRuVe4Ij5gsOLzFQn3TlNKGfEjtSSxzc5wMkfTSPIZDAdBvJOcqShUSqRKKhQpCVEUkpBQm gYSR0E2kdaEXZiidck7pPuSU6joKMJMiTek5BYI4JJkYouj9dSKOydDzSTWJyaI8cEIwOj5Ha5+U JDp7yuxoB+zbHWDWV5lOMTTyT0x0nAdKLyT3K9aSbQdX4usyRkJhI7DdexJRzlR0DB+fNJwEp8re Uz+8iVPA2B7yUUTCJVIZFQY6+UxJb6FRzGMmBWRRJoOVLHyJ8tkyKMYmP+LOSSfiKkOkUnYRjb3G ZLi6ztvdTuo/I9BLO6dPr1htBrInLkqN00iLDl1H2C8GieU49zpmg8Z60cIfOF5M5M4JwpxEsB7G AxhC0QpC0gbDuGgmcJY90RgcYcxrIbo2U2JulEqUphBb6dblj1kqONST2cLSqLKN5iS0kwxI0rdG FBYZAtoPiC3IIWrfIRGPoaVS0igzRZiLkkqy0LT8nv13xH+BiLkbJG5eiUP4lkLFGCSVMBwCjC4b ElixMS45DUMCVH8KXBgY9cLEsUUZGuhOgVI2kmMlhK6HWRevEUxBIIEEvYAyqRS8OyTnJjFGcJ4r RLiYpv0fCfNJaOtd+gvC04R4+YdkVDzMA1diZUWBZg7Sr2gcD9J9qaE+aJvqfOX2eM0VDmBwKkCW JPoKMibGCReQesmH2FSI5DAf4lWLwmyxZ2q+JZGC865IcSn0J+zz5wb3PkkNU0l0ndCdvKfzNAfm LlgzOgG8/ASHjLOpXo6dlDMEAxz0HdoCAwmAfhJ+YtFBYsqxgTJDqmNCodw/WP1RJ4w4z64faSR8 mb/bW350ve16XvKHRVRe6yG5Kk7NrwAh+OEnJSCDVCyJ3qQVxgwYNXLIVxODsMGDBqyKQ7CcHYYM GCsXEklGWQ7icFcRCQkYSKxBMkEMgMRLIH0gY3ySSYFVpROAN9EiiQUNXJyZAnkePXFyxRNw5gob jMPbibYRNofKexknS8GR8yoSpSUqKkocD2WS5PtFLLQQjGj6kIoUCpYhXEKhQrEoHUE/cOoo2cYb QvQ0NySx6Ic4+wcpywxSJmxeNHnR2jzi8TuFQl4c8/XNCW1k5RVukb+iZeYrA5gyLwfsSwbYsNQL dAYjjSiYqv3OVbkUxIBKklBmuXDuhQsIUwUWthFV9rNJtEm/tb8/KKoxCxu+ey1rY1U8CSjFOQ+c RB1BokFrDyYmCWWWn0JlxbjYGSSRyGSczGOeZGq6S1QfsdqXl8A1JW6qq4sFCrhOYOHLJiGMZxOU 0KCiihRGdEc/RNXgbj7NCojKI3mIP2E2wVKL2cxjCipJJzJMYn70ckSck+1qmaPPLMz7l13QSP39 KZryQ5kUShKJJMihoiI9JzpJqzFz4jZcg3d5taEME7SFwP0MBjCFotGy6TnlymRNpw7EOi5VTMnL 9phG4ic+JaQZnOXFy5ZMVQxMBLSI9Nlqp2RGUsvGWYzLIwkhkVIYXhYSySyCxJ8BYYhUG0MCfSJd UTfyk6SWMSXkpER8z0hc48SxGJuwKOEo2Fi5eyTqZfRWB1DklzQo2D4cL2ta1rWtYfOm5+UiyJzj 9WBdJFFHIsdVSekN2NSeFgt2oxJUk5iVE+BYWkRYKguFTctJgSqKTxTeTPKHWDV8aqqpVHSJ1HlI RiS6omFJvzqylrMA5N33qXiT8d0riPIzSeZJzIiNScEmA1KF4i7SNpdmtNoMqugDFQ28/SBsqXe0 HIFICeliQF51Jy9JG0Yrfb+tH0YRHOcgNSw+cjCiClftjDaBjIjIdZ19KTjlI2yPCEOSpETQpDwM JOuw7nensoSd8lIebz7e4Q198Oxmkmx2rHkc4movEXEiqwT52wQ5QN1wAVIhkD4x9SGgSaiPmdHp 47Q7CcD6Q+MLEuk2anmLdo3DlzK9AgWL5wzpmUwV9Acj22ih2q3ST0zcek6/UdZjYX8TqJZLjuJU OUnuxFxqdMOacxO0ZRH8ikG47DSdV/zOb6STpSe1+QvJPz7h282qOt4fqP9VB2CFFlB8I1p4KkfP rfFbxve1l6LlLUMd/dcPZbX3iaKSQ/+LuSKcKEhw4T2pgA==