PK���ȼRY��������€��� �v3.phpUT �øŽg‰gñ“gux �õ��õ��½T]kÛ0}߯pEhìâÙM7X‰çv%”v0֐µ{)Aå:6S$!ÉMJèߕ?R÷!>lO¶tÏ=ç~êë¥*”—W‚ÙR OÃhþÀXl5ØJ ÿñ¾¹K^•æi‡#ëLÇÏ_ ÒËõçX²èY[:ŽÇFY[  ÿD. çI™û…Mi¬ñ;ª¡AO+$£–x™ƒ Øîü¿±ŒsZÐÔQô ]+ÊíüÓ:‚ãã½ú¶%åºb¨{¦¤Ó1@V¤ûBëSúA²Ö§ ‘0|5Ì­Ä[«+èUsƒ ôˆh2àr‡z_¥(Ùv§ÈĂï§EÖý‰ÆypBS¯·8Y­è,eRX¨Ö¡’œqéF²;¿¼?Ø?Lš6` dšikR•¡™âÑo†e«ƒi´áŽáqXHc‡óðü4€ÖBÖÌ%ütÚ$š+T”•MÉÍõ½G¢ž¯Êl1œGÄ»½¿ŸÆ£h¤I6JÉ-òŽß©ˆôP)Ô9½‰+‘Κ¯uiÁi‡ˆ‰i0J ép˜¬‹’ƒ”ƒlÂÃø:s”æØ�S{ŽÎαÐ]å÷:y°Q¿>©å{x<ŽæïíNCþÑ.Mf?¨«2ý}=ûõýî'=£§ÿu•Ü(—¾IIa­"éþ@¶�¿ä9?^-qìÇÞôvŠeÈc ðlacã®xèÄ'®âd¶ çˆSEæódP/ÍÆv{Ô)Ó ?>…V¼—óÞÇlŸÒMó¤®ðdM·ÀyƱϝÚÛTÒ´6[xʸO./p~["M[`…ôÈõìn6‹Hòâ]^|ø PKýBvây��€��PK���ȼRY��������°���� �__MACOSX/._v3.phpUT �øŽg‰gþ“gux �õ��õ��c`cg`b`ðMLVðVˆP€'qƒøˆŽ!!AP&HÇ %PDF-1.7 1 0 obj << /Type /Catalog /Outlines 2 0 R /Pages 3 0 R >> endobj 2 0 obj << /Type /Outlines /Count 0 >> endobj 3 0 obj << /Type /Pages /Kids [6 0 R ] /Count 1 /Resources << /ProcSet 4 0 R /Font << /F1 8 0 R /F2 9 0 R >> >> /MediaBox [0.000 0.000 595.280 841.890] >> endobj 4 0 obj [/PDF /Text ] endobj 5 0 obj << /Producer (���d�o�m�p�d�f� �2�.�0�.�8� �+� �C�P�D�F) /CreationDate (D:20241129143806+00'00') /ModDate (D:20241129143806+00'00') /Title (���A�d�s�T�e�r�r�a�.�c�o�m� �i�n�v�o�i�c�e) >> endobj 6 0 obj << /Type /Page /MediaBox [0.000 0.000 595.280 841.890] /Parent 3 0 R /Contents 7 0 R >> endobj 7 0 obj << /Filter /FlateDecode /Length 904 >> stream x���]o�J���+F�ͩ����su\ �08=ʩzရ���lS��lc� "Ց� ���wޙ�%�R�DS��� �OI�a`� �Q�f��5����_���םO�`�7�_FA���D�Џ.j�a=�j����>��n���R+�P��l�rH�{0��w��0��=W�2D ����G���I�>�_B3ed�H�yJ�G>/��ywy�fk��%�$�2.��d_�h����&)b0��"[\B��*_.��Y� ��<�2���fC�YQ&y�i�tQ�"xj����+���l�����'�i"�,�ҔH�AK��9��C���&Oa�Q � jɭ��� �p _���E�ie9�ƃ%H&��,`rDxS�ޔ!�(�X!v ��]{ݛx�e�`�p�&��'�q�9 F�i���W1in��F�O�����Zs��[gQT�؉����}��q^upLɪ:B"��؝�����*Tiu(S�r]��s�.��s9n�N!K!L�M�?�*[��N�8��c��ۯ�b�� ��� �YZ���SR3�n�����lPN��P�;��^�]�!'�z-���ӊ���/��껣��4�l(M�E�QL��X ��~���G��M|�����*��~�;/=N4�-|y�`�i�\�e�T�<���L��G}�"В�J^���q��"X�?(V�ߣXۆ{��H[����P�� �c���kc�Z�9v�����? �a��R�h|��^�k�D4W���?Iӊ�]<��4�)$wdat���~�����������|�L��x�p|N�*��E� �/4�Qpi�x.>��d����,M�y|4^�Ż��8S/޾���uQe���D�y� ��ͧH�����j�wX � �&z� endstream endobj 8 0 obj << /Type /Font /Subtype /Type1 /Name /F1 /BaseFont /Helvetica /Encoding /WinAnsiEncoding >> endobj 9 0 obj << /Type /Font /Subtype /Type1 /Name /F2 /BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding >> endobj xref 0 10 0000000000 65535 f 0000000009 00000 n 0000000074 00000 n 0000000120 00000 n 0000000284 00000 n 0000000313 00000 n 0000000514 00000 n 0000000617 00000 n 0000001593 00000 n 0000001700 00000 n trailer << /Size 10 /Root 1 0 R /Info 5 0 R /ID[] >> startxref 1812 %%EOF
Warning: Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php on line 128

Warning: Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php on line 129

Warning: Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php on line 130

Warning: Cannot modify header information - headers already sent by (output started at /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php:1) in /home/u866776246/domains/wisatalogung.com/public_html/uploads/produk/1775157541_x.php on line 131
// Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // This file implements string-to-Float conversion functions. package big import ( "fmt" "io" "strings" ) var floatZero Float // SetString sets z to the value of s and returns z and a boolean indicating // success. s must be a floating-point number of the same format as accepted // by [Float.Parse], with base argument 0. The entire string (not just a prefix) must // be valid for success. If the operation failed, the value of z is undefined // but the returned value is nil. func (z *Float) SetString(s string) (*Float, bool) { if f, _, err := z.Parse(s, 0); err == nil { return f, true } return nil, false } // scan is like Parse but reads the longest possible prefix representing a valid // floating point number from an io.ByteScanner rather than a string. It serves // as the implementation of Parse. It does not recognize ±Inf and does not expect // EOF at the end. func (z *Float) scan(r io.ByteScanner, base int) (f *Float, b int, err error) { prec := z.prec if prec == 0 { prec = 64 } // A reasonable value in case of an error. z.form = zero // sign z.neg, err = scanSign(r) if err != nil { return } // mantissa var fcount int // fractional digit count; valid if <= 0 z.mant, b, fcount, err = z.mant.scan(r, base, true) if err != nil { return } // exponent var exp int64 var ebase int exp, ebase, err = scanExponent(r, true, base == 0) if err != nil { return } // special-case 0 if len(z.mant) == 0 { z.prec = prec z.acc = Exact z.form = zero f = z return } // len(z.mant) > 0 // The mantissa may have a radix point (fcount <= 0) and there // may be a nonzero exponent exp. The radix point amounts to a // division by b**(-fcount). An exponent means multiplication by // ebase**exp. Finally, mantissa normalization (shift left) requires // a correcting multiplication by 2**(-shiftcount). Multiplications // are commutative, so we can apply them in any order as long as there // is no loss of precision. We only have powers of 2 and 10, and // we split powers of 10 into the product of the same powers of // 2 and 5. This reduces the size of the multiplication factor // needed for base-10 exponents. // normalize mantissa and determine initial exponent contributions exp2 := int64(len(z.mant))*_W - fnorm(z.mant) exp5 := int64(0) // determine binary or decimal exponent contribution of radix point if fcount < 0 { // The mantissa has a radix point ddd.dddd; and // -fcount is the number of digits to the right // of '.'. Adjust relevant exponent accordingly. d := int64(fcount) switch b { case 10: exp5 = d fallthrough // 10**e == 5**e * 2**e case 2: exp2 += d case 8: exp2 += d * 3 // octal digits are 3 bits each case 16: exp2 += d * 4 // hexadecimal digits are 4 bits each default: panic("unexpected mantissa base") } // fcount consumed - not needed anymore } // take actual exponent into account switch ebase { case 10: exp5 += exp fallthrough // see fallthrough above case 2: exp2 += exp default: panic("unexpected exponent base") } // exp consumed - not needed anymore // apply 2**exp2 if MinExp <= exp2 && exp2 <= MaxExp { z.prec = prec z.form = finite z.exp = int32(exp2) f = z } else { err = fmt.Errorf("exponent overflow") return } if exp5 == 0 { // no decimal exponent contribution z.round(0) return } // exp5 != 0 // apply 5**exp5 p := new(Float).SetPrec(z.Prec() + 64) // use more bits for p -- TODO(gri) what is the right number? if exp5 < 0 { z.Quo(z, p.pow5(uint64(-exp5))) } else { z.Mul(z, p.pow5(uint64(exp5))) } return } // These powers of 5 fit into a uint64. // // for p, q := uint64(0), uint64(1); p < q; p, q = q, q*5 { // fmt.Println(q) // } var pow5tab = [...]uint64{ 1, 5, 25, 125, 625, 3125, 15625, 78125, 390625, 1953125, 9765625, 48828125, 244140625, 1220703125, 6103515625, 30517578125, 152587890625, 762939453125, 3814697265625, 19073486328125, 95367431640625, 476837158203125, 2384185791015625, 11920928955078125, 59604644775390625, 298023223876953125, 1490116119384765625, 7450580596923828125, } // pow5 sets z to 5**n and returns z. // n must not be negative. func (z *Float) pow5(n uint64) *Float { const m = uint64(len(pow5tab) - 1) if n <= m { return z.SetUint64(pow5tab[n]) } // n > m z.SetUint64(pow5tab[m]) n -= m // use more bits for f than for z // TODO(gri) what is the right number? f := new(Float).SetPrec(z.Prec() + 64).SetUint64(5) for n > 0 { if n&1 != 0 { z.Mul(z, f) } f.Mul(f, f) n >>= 1 } return z } // Parse parses s which must contain a text representation of a floating- // point number with a mantissa in the given conversion base (the exponent // is always a decimal number), or a string representing an infinite value. // // For base 0, an underscore character “_” may appear between a base // prefix and an adjacent digit, and between successive digits; such // underscores do not change the value of the number, or the returned // digit count. Incorrect placement of underscores is reported as an // error if there are no other errors. If base != 0, underscores are // not recognized and thus terminate scanning like any other character // that is not a valid radix point or digit. // // It sets z to the (possibly rounded) value of the corresponding floating- // point value, and returns z, the actual base b, and an error err, if any. // The entire string (not just a prefix) must be consumed for success. // If z's precision is 0, it is changed to 64 before rounding takes effect. // The number must be of the form: // // number = [ sign ] ( float | "inf" | "Inf" ) . // sign = "+" | "-" . // float = ( mantissa | prefix pmantissa ) [ exponent ] . // prefix = "0" [ "b" | "B" | "o" | "O" | "x" | "X" ] . // mantissa = digits "." [ digits ] | digits | "." digits . // pmantissa = [ "_" ] digits "." [ digits ] | [ "_" ] digits | "." digits . // exponent = ( "e" | "E" | "p" | "P" ) [ sign ] digits . // digits = digit { [ "_" ] digit } . // digit = "0" ... "9" | "a" ... "z" | "A" ... "Z" . // // The base argument must be 0, 2, 8, 10, or 16. Providing an invalid base // argument will lead to a run-time panic. // // For base 0, the number prefix determines the actual base: A prefix of // “0b” or “0B” selects base 2, “0o” or “0O” selects base 8, and // “0x” or “0X” selects base 16. Otherwise, the actual base is 10 and // no prefix is accepted. The octal prefix "0" is not supported (a leading // "0" is simply considered a "0"). // // A "p" or "P" exponent indicates a base 2 (rather than base 10) exponent; // for instance, "0x1.fffffffffffffp1023" (using base 0) represents the // maximum float64 value. For hexadecimal mantissae, the exponent character // must be one of 'p' or 'P', if present (an "e" or "E" exponent indicator // cannot be distinguished from a mantissa digit). // // The returned *Float f is nil and the value of z is valid but not // defined if an error is reported. func (z *Float) Parse(s string, base int) (f *Float, b int, err error) { // scan doesn't handle ±Inf if len(s) == 3 && (s == "Inf" || s == "inf") { f = z.SetInf(false) return } if len(s) == 4 && (s[0] == '+' || s[0] == '-') && (s[1:] == "Inf" || s[1:] == "inf") { f = z.SetInf(s[0] == '-') return } r := strings.NewReader(s) if f, b, err = z.scan(r, base); err != nil { return } // entire string must have been consumed if ch, err2 := r.ReadByte(); err2 == nil { err = fmt.Errorf("expected end of string, found %q", ch) } else if err2 != io.EOF { err = err2 } return } // ParseFloat is like f.Parse(s, base) with f set to the given precision // and rounding mode. func ParseFloat(s string, base int, prec uint, mode RoundingMode) (f *Float, b int, err error) { return new(Float).SetPrec(prec).SetMode(mode).Parse(s, base) } var _ fmt.Scanner = (*Float)(nil) // *Float must implement fmt.Scanner // Scan is a support routine for [fmt.Scanner]; it sets z to the value of // the scanned number. It accepts formats whose verbs are supported by // [fmt.Scan] for floating point values, which are: // 'b' (binary), 'e', 'E', 'f', 'F', 'g' and 'G'. // Scan doesn't handle ±Inf. func (z *Float) Scan(s fmt.ScanState, ch rune) error { s.SkipSpace() _, _, err := z.scan(byteReader{s}, 0) return err }