www.digitalmars.com         C & C++   DMDScript  

c++.stlsoft - string_view in 1.8.3b4

reply "Pablo Aguilar" <paguilarg hotmail.com> writes:
I was looking at string_view to figure out how to implement BASIC-style 
left$, right$ and mid$ functions here's a few comments after looking at the 
source...

1) I think the (rhs, pos, cch) constructor, is missing an assert for (pos + 
cch < rhs.length), pos is being checked but cch is taken literally with no 
checks
2) The (char const* s, cch) constructor is missing the check for cch's 
validity also
3) Doesn't m_base have to be pointed to m_cstr if m_cstr is allocated (when 
using c_str()) ?

On "standard" issues (and please correct me since I'm likely be outdated on 
this):
a) Can you can construct using the (char const* s[,cch]) versions from 
pointers returned by c_str()? Aren't these pointers NOT guaranteed to be 
valid after the function call?
b) How would you construct a string_view from an std::string if:
    - iterators aren't necessarily pointers (so it can't be done through 
begin(), end())
    - string memory isn't guaranteed to be contiguous (as it was pointed out 
some time ago, but I can't find the post) ? (so it can't be done either with 
&str[pos], &str[pos + cch])

I assume it was considered storing a pair of iterators rather than a base 
and length as a possibility, what were the cons for that approach?

BTW, saw myself in string_view's header, thanks!


Pablo
Mar 30 2005
next sibling parent reply "Matthew" <admin.hat stlsoft.dot.org> writes:
"Pablo Aguilar" <paguilarg hotmail.com> wrote in message
news:d2flvs$2jic$1 digitaldaemon.com...

I was looking at string_view to figure out how to implement BASIC-style left$,
right$ and mid$ functions here's a few 
comments after looking at the source...


Cool. Did you figure it out? It might be a nice addition ...


 1) I think the (rhs, pos, cch) constructor, is missing an assert for (pos +
cch < rhs.length), pos is being checked 
 but cch is taken literally with no checks


I think I thought about this, and considered that the user might expect to be
able to 'know' more about the real extent 
of available string than the rhs string_view instance.

I'm still not 100% about it, so I'd be interested in hearing opinions on this
from others.


 2) The (char const* s, cch) constructor is missing the check for cch's
validity also


Definitely not in this case. <g>

One important point of string_view is that it can be applied to any sequence of
bytes, whether or not they're 
null-terminated. Also, string_view, in common with std::basic_string (and BSTR,
and many other string types) may contain 
embedded NUL characters. Given that, how would we 'check' cch? :-)


 3) Doesn't m_base have to be pointed to m_cstr if m_cstr is allocated (when
using c_str()) ?


I thought it did. :$ Let me check ...

... ah, now I remember: I reasoned that users would want to be able to depend
on data() and the iterators pointing into 
the original memory. Now that I'm reminded of that, I think it's definitely a
powerful argument.


 On "standard" issues (and please correct me since I'm likely be outdated on
this):
 a) Can you can construct using the (char const* s[,cch]) versions from
pointers returned by c_str()? Aren't these 
 pointers NOT guaranteed to be valid after the function call?


I don't follow. Can you rephrase? (and please stipulate explicitly which class
you're meaning on both lhs and rhs of 
such interactions.)


 b) How would you construct a string_view from an std::string if:
    - iterators aren't necessarily pointers (so it can't be done through
begin(), end())
    - string memory isn't guaranteed to be contiguous (as it was pointed out
some time ago, but I can't find the post) 
 ? (so it can't be done either with &str[pos], &str[pos + cch])


Doing it is simple:

    std::basic_string<char> ss("Pablo's help is highly prized");
    string_view<char>        sv(ss.data(), ss.length());

But you're correct in suggesting that it's not theoretically valid to do so.
But (I think) you're missing a more 
fundamental point.

data() is guaranteed to return a contiguous array of characters whose first
size() elements are identical to those in 
the actual storage (if different). The returned pointer is invalidated by a
host of different operations on 
std::basic_string - including c_str()! - which would invalidate the pointer
that the string_view instance is holding 
onto.

But, and this is where this bad news is actually not that bad, the exact same
could be said if a string-view class held 
onto iterators. Anything that invalidates iterators will invalidate the pointer
returned by data(), after all. <g>

So, bizarrely as it seems, the issue is moot. :-)

(BTW: This is all good stuff for doing in the documentation. If only someone
was motivated to help me out on the docs 
.... <G>)


 I assume it was considered storing a pair of iterators rather than a base and
length as a possibility, what were the 
 cons for that approach?


Theoretically, string_view is _only_ for use with *arrays of characters*. The
fact that a standards compliant string 
class (or indeed any other string class) may store non-continguously, means
that iterators may not be used.

Practically speaking, I've found that it's more convenient and more efficient
to represent strings as len+ptr rather 
than two bounding ptrs. (And this will be reflected in the forthcoming rewrite
of recls: recls2)


 BTW, saw myself in string_view's header, thanks!


You're entirely welcome. :-)

I'm a strong believer in people's help being recognised and valued.

Cheers

Matthew
Mar 31 2005
next sibling parent reply "Pablo Aguilar" <paguilarg hotmail.com> writes:
"Matthew" <admin.hat stlsoft.dot.org> wrote in message 
news:d2gc12$bv9$1 digitaldaemon.com...

 "Pablo Aguilar" <paguilarg hotmail.com> wrote in message 
 news:d2flvs$2jic$1 digitaldaemon.com...

I was looking at string_view to figure out how to implement BASIC-style 
left$, right$ and mid$ functions here's a few
comments after looking at the source...


 Cool. Did you figure it out? It might be a nice addition ...


I'll reply to the whole message in a while... for now, would you mind 
looking at the following, it compiles fine under VC71, but either complains 
about "typename" being used outsie a template or ICEs on me with VC6.5

<code>
template<typename string_type>
stlsoft_ns_qual(basic_string_view)<typename string_type::value_type>
right_view(
      string_type const& str
    , typename string_type::size_type cch
)
{
    typedef stlsoft_ns_qual(basic_string_view)<typename 
string_type::value_type> string_view; // <<< complains/crashes here
    // This assumes that string types below have contiguous memory storage
    typename string_type::size_type size = str.size();

    // We know we're not modifying the string
    // so the const_cast is ok, we need it to
    // get the reference version of operator[]
    // otherwise we get an rvalue return type
    string_type& ncstr = *const_cast<string_type*>(&str);
    return (size <= cch)
        ? string_view(&ncstr[0], size)
        : string_view(&ncstr[size - cch], cch)
        ;
}

template<typename char_type>
stlsoft_ns_qual(basic_string_view)<char_type>
right_view(
      char_type const* str
    , size_t cch
)
{
    typedef stlsoft_ns_qual(basic_string_view)<char_type> string_view;
    size_t size = c_str_len(str);
    return (size <= cch)
        ? string_view(str, cch)
        : string_view(str + (size - cch), cch)
        ;
}
</code>

Once this works, left_view and mid_view should be trivial to implement...
Maybe taking the address of characters in certain positions should be 
replaced by using a string traits class.
Attached is the test program I'm using...

Thanks for your help...

Pablo


begin 666 string_algo_test.cpp


M<W1R:6YG+FAP<#X-"B-I;F-L=61E(#QS;V9T<W1E96PO<W1R:6YG7V%L9V\N

M;64 8VAA<E]T>7!E/ T*=F]I9"!R=6Y?=&5S="AC:&%R7W1Y<&4 8V]N<W0J
M('1E<W0L('-I>F5?="!C8V L(&-H87)?='EP92!C;VYS="H 8VUP*0T*>PT*
M"71Y<&5D968 <W1L<V]F=%]N<U]Q=6%L*&)A<VEC7W-T<FEN9U]V:65W*3QC






M=%]N<U]Q=6%L*&)A<VEC7W-I;7!L95]S=')I;F<I/&-H87)?='EP93X <W-T


M" T*:6YT(&UA:6XH:6YT(&%R9V,L(&-H87(J(&%R9W9;72D-"GL-" ER=6Y?


*<FX ,#L-"GT-" ``
`
end
Mar 31 2005
parent reply "Matthew" <admin stlsoft.dot.dot.dot.dot.org> writes:
I need softsteel/string_algo.hpp

Can you post / email it to me?

"Pablo Aguilar" <paguilarg hotmail.com> wrote in message
news:d2hslp$21mv$1 digitaldaemon.com...

 "Matthew" <admin.hat stlsoft.dot.org> wrote in message
news:d2gc12$bv9$1 digitaldaemon.com...

 "Pablo Aguilar" <paguilarg hotmail.com> wrote in message
news:d2flvs$2jic$1 digitaldaemon.com...

I was looking at string_view to figure out how to implement BASIC-style left$,
right$ and mid$ functions here's a few
comments after looking at the source...


 Cool. Did you figure it out? It might be a nice addition ...


 I'll reply to the whole message in a while... for now, would you mind looking
at the following, it compiles fine under 
 VC71, but either complains about "typename" being used outsie a template or
ICEs on me with VC6.5

 <code>
 template<typename string_type>
 stlsoft_ns_qual(basic_string_view)<typename string_type::value_type>
 right_view(
      string_type const& str
    , typename string_type::size_type cch
 )
 {
    typedef stlsoft_ns_qual(basic_string_view)<typename
string_type::value_type> string_view; // <<< complains/crashes 
 here
    // This assumes that string types below have contiguous memory storage
    typename string_type::size_type size = str.size();

    // We know we're not modifying the string
    // so the const_cast is ok, we need it to
    // get the reference version of operator[]
    // otherwise we get an rvalue return type
    string_type& ncstr = *const_cast<string_type*>(&str);
    return (size <= cch)
        ? string_view(&ncstr[0], size)
        : string_view(&ncstr[size - cch], cch)
        ;
 }

 template<typename char_type>
 stlsoft_ns_qual(basic_string_view)<char_type>
 right_view(
      char_type const* str
    , size_t cch
 )
 {
    typedef stlsoft_ns_qual(basic_string_view)<char_type> string_view;
    size_t size = c_str_len(str);
    return (size <= cch)
        ? string_view(str, cch)
        : string_view(str + (size - cch), cch)
        ;
 }
 </code>

 Once this works, left_view and mid_view should be trivial to implement...
 Maybe taking the address of characters in certain positions should be replaced
by using a string traits class.
 Attached is the test program I'm using...

 Thanks for your help...

 Pablo
Mar 31 2005
parent "Matthew" <admin stlsoft.dot.dot.dot.dot.org> writes:
Doh! Belay that order. :$

"Matthew" <admin stlsoft.dot.dot.dot.dot.org> wrote in message
news:d2ht4g$226m$1 digitaldaemon.com...

I need softsteel/string_algo.hpp

 Can you post / email it to me?

 "Pablo Aguilar" <paguilarg hotmail.com> wrote in message
news:d2hslp$21mv$1 digitaldaemon.com...

 "Matthew" <admin.hat stlsoft.dot.org> wrote in message
news:d2gc12$bv9$1 digitaldaemon.com...

 "Pablo Aguilar" <paguilarg hotmail.com> wrote in message
news:d2flvs$2jic$1 digitaldaemon.com...

I was looking at string_view to figure out how to implement BASIC-style left$,
right$ and mid$ functions here's a 
few
comments after looking at the source...


 Cool. Did you figure it out? It might be a nice addition ...


 I'll reply to the whole message in a while... for now, would you mind looking
at the following, it compiles fine 
 under VC71, but either complains about "typename" being used outsie a template
or ICEs on me with VC6.5

 <code>
 template<typename string_type>
 stlsoft_ns_qual(basic_string_view)<typename string_type::value_type>
 right_view(
      string_type const& str
    , typename string_type::size_type cch
 )
 {
    typedef stlsoft_ns_qual(basic_string_view)<typename
string_type::value_type> string_view; // <<< complains/crashes 
 here
    // This assumes that string types below have contiguous memory storage
    typename string_type::size_type size = str.size();

    // We know we're not modifying the string
    // so the const_cast is ok, we need it to
    // get the reference version of operator[]
    // otherwise we get an rvalue return type
    string_type& ncstr = *const_cast<string_type*>(&str);
    return (size <= cch)
        ? string_view(&ncstr[0], size)
        : string_view(&ncstr[size - cch], cch)
        ;
 }

 template<typename char_type>
 stlsoft_ns_qual(basic_string_view)<char_type>
 right_view(
      char_type const* str
    , size_t cch
 )
 {
    typedef stlsoft_ns_qual(basic_string_view)<char_type> string_view;
    size_t size = c_str_len(str);
    return (size <= cch)
        ? string_view(str, cch)
        : string_view(str + (size - cch), cch)
        ;
 }
 </code>

 Once this works, left_view and mid_view should be trivial to implement...
 Maybe taking the address of characters in certain positions should be replaced
by using a string traits class.
 Attached is the test program I'm using...

 Thanks for your help...

 Pablo
Mar 31 2005
prev sibling parent reply "Pablo Aguilar" <paguilarg hotmail.com> writes:
"Matthew" <admin.hat stlsoft.dot.org> wrote in message 
news:d2gc12$bv9$1 digitaldaemon.com...

 1) I think the (rhs, pos, cch) constructor, is missing an assert for (pos 
 + cch < rhs.length), pos is being checked but cch is taken literally with 
 no checks


 I think I thought about this, and considered that the user might expect to 
 be able to 'know' more about the real extent of available string than the 
 rhs string_view instance.


Interesting point, this thought never crossed my mind...


 I'm still not 100% about it, so I'd be interested in hearing opinions on 
 this from others.


I guess you could come up with a scenario in which you'd need a longer view 
than you have and know you can get it but... I'd think the only way to be 
sure there's more info available than what your current view knows there is, 
would be to know the source string for that view, in which case, wouldn't it 
be more "proper" to construct the new view from the original source rather 
than over-reading from the short view?

If I had to cast a vote, I'd say the length should be checked...


 2) The (char const* s, cch) constructor is missing the check for cch's 
 validity also


 Definitely not in this case. <g>

 One important point of string_view is that it can be applied to any 
 sequence of bytes, whether or not they're null-terminated. Also, 
 string_view, in common with std::basic_string (and BSTR, and many other 
 string types) may contain embedded NUL characters. Given that, how would 
 we 'check' cch? :-)


No argument here...


 3) Doesn't m_base have to be pointed to m_cstr if m_cstr is allocated 
 (when using c_str()) ?


 I thought it did. :$ Let me check ...

 ... ah, now I remember: I reasoned that users would want to be able to 
 depend on data() and the iterators pointing into the original memory. Now 
 that I'm reminded of that, I think it's definitely a powerful argument.


Again, no argument...


 On "standard" issues (and please correct me since I'm likely be outdated 
 on this):
 a) Can you can construct using the (char const* s[,cch]) versions from 
 pointers returned by c_str()? Aren't these pointers NOT guaranteed to be 
 valid after the function call?


 I don't follow. Can you rephrase? (and please stipulate explicitly which 
 class you're meaning on both lhs and rhs of such interactions.)


Just reread my most, sounds weird...
I meant, that you couldn't construct from a c_str() returned pointer, since 
the data pointed to could be easily invalidated as you stated below.


 b) How would you construct a string_view from an std::string if:
    - iterators aren't necessarily pointers (so it can't be done through 
 begin(), end())
    - string memory isn't guaranteed to be contiguous (as it was pointed 
 out some time ago, but I can't find the post) ? (so it can't be done 
 either with &str[pos], &str[pos + cch])


 Doing it is simple:

    std::basic_string<char> ss("Pablo's help is highly prized");
    string_view<char>        sv(ss.data(), ss.length());

 But you're correct in suggesting that it's not theoretically valid to do 
 so. But (I think) you're missing a more fundamental point.

 data() is guaranteed to return a contiguous array of characters whose 
 first size() elements are identical to those in the actual storage (if 
 different). The returned pointer is invalidated by a host of different 
 operations on std::basic_string - including c_str()! - which would 
 invalidate the pointer that the string_view instance is holding onto.


Ok, you got me here, I wasn't even aware of data()'s existance let alone 
requirements...


 But, and this is where this bad news is actually not that bad, the exact 
 same could be said if a string-view class held onto iterators. Anything 
 that invalidates iterators will invalidate the pointer returned by data(), 
 after all. <g>

 So, bizarrely as it seems, the issue is moot. :-)


Agreed.


 (BTW: This is all good stuff for doing in the documentation. If only 
 someone was motivated to help me out on the docs .... <G>)


In due time...


 I assume it was considered storing a pair of iterators rather than a base 
 and length as a possibility, what were the cons for that approach?


 Theoretically, string_view is _only_ for use with *arrays of characters*. 
 The fact that a standards compliant string class (or indeed any other 
 string class) may store non-continguously, means that iterators may not be 
 used.

 Practically speaking, I've found that it's more convenient and more 
 efficient to represent strings as len+ptr rather than two bounding ptrs. 
 (And this will be reflected in the forthcoming rewrite of recls: recls2)


Interesting... could you give a brief insight as to why this is so?


 BTW, saw myself in string_view's header, thanks!


 You're entirely welcome. :-)

 I'm a strong believer in people's help being recognised and valued.


Well, thanks again...


 Cheers

 Matthew


Pablo
Apr 01 2005
parent "Matthew" <admin.hat stlsoft.dot.org> writes:
"Pablo Aguilar" <paguilarg hotmail.com> wrote in message
news:d2kkpd$1q6i$1 digitaldaemon.com...

 "Matthew" <admin.hat stlsoft.dot.org> wrote in message
news:d2gc12$bv9$1 digitaldaemon.com...

 1) I think the (rhs, pos, cch) constructor, is missing an assert for (pos +
cch < rhs.length), pos is being checked 
 but cch is taken literally with no checks


 I think I thought about this, and considered that the user might expect to be
able to 'know' more about the real 
 extent of available string than the rhs string_view instance.


 Interesting point, this thought never crossed my mind...


 I'm still not 100% about it, so I'd be interested in hearing opinions on this
from others.


 I guess you could come up with a scenario in which you'd need a longer view
than you have and know you can get it 
 but... I'd think the only way to be sure there's more info available than what
your current view knows there is, would 
 be to know the source string for that view, in which case, wouldn't it be more
"proper" to construct the new view from 
 the original source rather than over-reading from the short view?

 If I had to cast a vote, I'd say the length should be checked...


 2) The (char const* s, cch) constructor is missing the check for cch's
validity also


 Definitely not in this case. <g>

 One important point of string_view is that it can be applied to any sequence
of bytes, whether or not they're 
 null-terminated. Also, string_view, in common with std::basic_string (and
BSTR, and many other string types) may 
 contain embedded NUL characters. Given that, how would we 'check' cch? :-)


 No argument here...


 3) Doesn't m_base have to be pointed to m_cstr if m_cstr is allocated (when
using c_str()) ?


 I thought it did. :$ Let me check ...

 ... ah, now I remember: I reasoned that users would want to be able to depend
on data() and the iterators pointing 
 into the original memory. Now that I'm reminded of that, I think it's
definitely a powerful argument.


 Again, no argument...


 On "standard" issues (and please correct me since I'm likely be outdated on
this):
 a) Can you can construct using the (char const* s[,cch]) versions from
pointers returned by c_str()? Aren't these 
 pointers NOT guaranteed to be valid after the function call?


 I don't follow. Can you rephrase? (and please stipulate explicitly which class
you're meaning on both lhs and rhs of 
 such interactions.)


 Just reread my most, sounds weird...
 I meant, that you couldn't construct from a c_str() returned pointer, since
the data pointed to could be easily 
 invalidated as you stated below.


 b) How would you construct a string_view from an std::string if:
    - iterators aren't necessarily pointers (so it can't be done through
begin(), end())
    - string memory isn't guaranteed to be contiguous (as it was pointed out
some time ago, but I can't find the 
 post) ? (so it can't be done either with &str[pos], &str[pos + cch])


 Doing it is simple:

    std::basic_string<char> ss("Pablo's help is highly prized");
    string_view<char>        sv(ss.data(), ss.length());

 But you're correct in suggesting that it's not theoretically valid to do so.
But (I think) you're missing a more 
 fundamental point.

 data() is guaranteed to return a contiguous array of characters whose first
size() elements are identical to those in 
 the actual storage (if different). The returned pointer is invalidated by a
host of different operations on 
 std::basic_string - including c_str()! - which would invalidate the pointer
that the string_view instance is holding 
 onto.


 Ok, you got me here, I wasn't even aware of data()'s existance let alone
requirements...


 But, and this is where this bad news is actually not that bad, the exact same
could be said if a string-view class 
 held onto iterators. Anything that invalidates iterators will invalidate the
pointer returned by data(), after all. 
 <g>

 So, bizarrely as it seems, the issue is moot. :-)


 Agreed.


Cool. Sounds like our reasoning tallies, which is a relief. :-)


 (BTW: This is all good stuff for doing in the documentation. If only someone
was motivated to help me out on the docs 
 .... <G>)


 In due time...


Just yanking ya. ;)


 I assume it was considered storing a pair of iterators rather than a base and
length as a possibility, what were the 
 cons for that approach?


 Theoretically, string_view is _only_ for use with *arrays of characters*. The
fact that a standards compliant string 
 class (or indeed any other string class) may store non-continguously, means
that iterators may not be used.

 Practically speaking, I've found that it's more convenient and more efficient
to represent strings as len+ptr rather 
 than two bounding ptrs. (And this will be reflected in the forthcoming rewrite
of recls: recls2)


 Interesting... could you give a brief insight as to why this is so?


Well, I find that I want to know the length more frequently that I want to have
the (one of the) end pointer. Given 
that, it's less efficient to know the end than the length.
Apr 04 2005
prev sibling parent reply "Matthew" <admin stlsoft.dot.dot.dot.dot.org> writes:
Here's the Arturius output. Very encouraging so far:

        arcc.debug -c --exception-handling=on --announce-tools
--compilers=bcc/5.6,cw/8,dm/beta-stlport,gcc/3.2,gcc/3.4,icl/7,icl/8,vc/6,vc/7,vc/7.1,v
c/8 -I..     -IH:\STLSoft\Identities\STLSoft\stlsoft  
-IH:\STLSoft\Identities\STLSoft\stlsoft\inprogress  
-IH:\STLSoft\Identities\STLSoft\stlsoft\re
search  --output-path=.\string_algo_test.obj ..\string_algo_test.cpp
Tool: bcc/5.6
Tool: cw/8
Tool: dm/beta-stlport
Tool: gcc/3.2
Tool: gcc/3.4
Tool: icl/7
Tool: icl/8
Tool: vc/6
..\string_algo_test.cpp(21): error C2899: typename cannot be used outside a
template declaration
..\string_algo_test.cpp(21): error C2899: typename cannot be used outside a
template declaration
..\string_algo_test.cpp(21): error C2899: typename cannot be used outside a
template declaration
..\string_algo_test.cpp(21): error C2899: typename cannot be used outside a
template declaration
Tool: vc/7
..\string_algo_test.cpp(15): fatal error C1507: previous user errors and
subsequent error recovery halt further 
compilation
Tool: vc/7.1
Tool: vc/8



"Pablo Aguilar" <paguilarg hotmail.com> wrote in message
news:d2flvs$2jic$1 digitaldaemon.com...

I was looking at string_view to figure out how to implement BASIC-style left$,
right$ and mid$ functions here's a few 
comments after looking at the source...

 1) I think the (rhs, pos, cch) constructor, is missing an assert for (pos +
cch < rhs.length), pos is being checked 
 but cch is taken literally with no checks
 2) The (char const* s, cch) constructor is missing the check for cch's
validity also
 3) Doesn't m_base have to be pointed to m_cstr if m_cstr is allocated (when
using c_str()) ?

 On "standard" issues (and please correct me since I'm likely be outdated on
this):
 a) Can you can construct using the (char const* s[,cch]) versions from
pointers returned by c_str()? Aren't these 
 pointers NOT guaranteed to be valid after the function call?
 b) How would you construct a string_view from an std::string if:
    - iterators aren't necessarily pointers (so it can't be done through
begin(), end())
    - string memory isn't guaranteed to be contiguous (as it was pointed out
some time ago, but I can't find the post) 
 ? (so it can't be done either with &str[pos], &str[pos + cch])

 I assume it was considered storing a pair of iterators rather than a base and
length as a possibility, what were the 
 cons for that approach?

 BTW, saw myself in string_view's header, thanks!


 Pablo
Mar 31 2005
next sibling parent "Matthew" <admin stlsoft.dot.dot.dot.dot.org> writes:
Getting rid of the compile error is easy: just take out the typename

    typedef stlsoft_ns_qual(basic_string_view)</* typename */
STRING_TYPE::value_type> string_view; // <<< 
complains/crashes here


However, then VC 6 has an internal compiler error. That's bound up with the
c-string form of right_view.

If that's not used in the client code, then all is well. If it's in: ICE.

If we comment out the other right_view, then the c-string form works fine.

If we have the c-string form and the following stub version, it all works fine

    template<ss_typename_param_k C>
    const ::stlsoft::basic_string_view<C> right_view(long, long, long n, C
const *s)
    {
        typedef ::stlsoft::basic_string_view<C> string_view_t;

        return string_view_t(s, n);
    }

c-string + following compilers fine

    template<ss_typename_param_k S>
    const ::stlsoft::basic_string_view<typename S::value_type> right_view(S
const &s, long, long n)
    {
        typedef ::stlsoft::basic_string_view<C> string_view_t;

        return string_view_t(s.data(), n);
    }

c-string + following compiles fine:

    template<ss_typename_param_k S>
    const ::stlsoft::basic_string_view<typename S::value_type> right_view(S
const &s, size_t n, long l)
    {
        typedef ::stlsoft::basic_string_view<C> string_view_t;

        return string_view_t(s.data(), n);
    }

c-string + following ICEs:

    template<ss_typename_param_k S>
    const ::stlsoft::basic_string_view<typename S::value_type> right_view(S
const &s, size_t n, long l = 1)
    {
        typedef ::stlsoft::basic_string_view<C> string_view_t;

        return string_view_t(s.data(), n);
    }

It seems, then, that the ICE comes from having two forms of right_view with one
template-type param and one (unsigned) 
integral param.

More digging required ....



"Matthew" <admin stlsoft.dot.dot.dot.dot.org> wrote in message
news:d2huui$23m1$1 digitaldaemon.com...

 Here's the Arturius output. Very encouraging so far:

        arcc.debug -c --exception-handling=on --announce-tools
--compilers=bcc/5.6,cw/8,dm/beta-stlport,gcc/3.2,gcc/3.4,icl/7,icl/8,vc/6,vc/7,vc/7.1,v
 
 8 -I..     -IH:\STLSoft\Identities\STLSoft\stlsoft  
-IH:\STLSoft\Identities\STLSoft\stlsoft\inprogress  
-IH:\STLSoft\Identities\STLSoft\stlsoft\re
 search  --output-path=.\string_algo_test.obj ..\string_algo_test.cpp
 Tool: bcc/5.6
 Tool: cw/8
 Tool: dm/beta-stlport
 Tool: gcc/3.2
 Tool: gcc/3.4
 Tool: icl/7
 Tool: icl/8
 Tool: vc/6
 ..\string_algo_test.cpp(21): error C2899: typename cannot be used outside a
template declaration
 ..\string_algo_test.cpp(21): error C2899: typename cannot be used outside a
template declaration
 ..\string_algo_test.cpp(21): error C2899: typename cannot be used outside a
template declaration
 ..\string_algo_test.cpp(21): error C2899: typename cannot be used outside a
template declaration
 Tool: vc/7
 ..\string_algo_test.cpp(15): fatal error C1507: previous user errors and
subsequent error recovery halt further 
 compilation
 Tool: vc/7.1
 Tool: vc/8



 "Pablo Aguilar" <paguilarg hotmail.com> wrote in message
news:d2flvs$2jic$1 digitaldaemon.com...

I was looking at string_view to figure out how to implement BASIC-style left$,
right$ and mid$ functions here's a few 
comments after looking at the source...

 1) I think the (rhs, pos, cch) constructor, is missing an assert for (pos +
cch < rhs.length), pos is being checked 
 but cch is taken literally with no checks
 2) The (char const* s, cch) constructor is missing the check for cch's
validity also
 3) Doesn't m_base have to be pointed to m_cstr if m_cstr is allocated (when
using c_str()) ?

 On "standard" issues (and please correct me since I'm likely be outdated on
this):
 a) Can you can construct using the (char const* s[,cch]) versions from
pointers returned by c_str()? Aren't these 
 pointers NOT guaranteed to be valid after the function call?
 b) How would you construct a string_view from an std::string if:
    - iterators aren't necessarily pointers (so it can't be done through
begin(), end())
    - string memory isn't guaranteed to be contiguous (as it was pointed out
some time ago, but I can't find the post) 
 ? (so it can't be done either with &str[pos], &str[pos + cch])

 I assume it was considered storing a pair of iterators rather than a base and
length as a possibility, what were the 
 cons for that approach?

 BTW, saw myself in string_view's header, thanks!


 Pablo
Mar 31 2005
prev sibling next sibling parent reply "Pablo Aguilar" <paguilarg hotmail.com> writes:
Great!

You tweaked first it right? I very much doubt it would've compiled that 
cleanly on all compilers!
Handy tool Arturius, BTW...

"Matthew" <admin stlsoft.dot.dot.dot.dot.org> wrote in message 
news:d2huui$23m1$1 digitaldaemon.com...

 Here's the Arturius output. Very encouraging so far:

        arcc.debug -c --exception-handling=on --announce-tools
--compilers=bcc/5.6,cw/8,dm/beta-stlport,gcc/3.2,gcc/3.4,icl/7,icl/8,vc/6,vc/7,vc/7.1,v
 
 8 -I..     -IH:\STLSoft\Identities\STLSoft\stlsoft  
-IH:\STLSoft\Identities\STLSoft\stlsoft\inprogress 
    -IH:\STLSoft\Identities\STLSoft\stlsoft\re
 search  --output-path=.\string_algo_test.obj ..\string_algo_test.cpp
 Tool: bcc/5.6
 Tool: cw/8
 Tool: dm/beta-stlport
 Tool: gcc/3.2
 Tool: gcc/3.4
 Tool: icl/7
 Tool: icl/8
 Tool: vc/6
 ..\string_algo_test.cpp(21): error C2899: typename cannot be used outside 
 a template declaration
 ..\string_algo_test.cpp(21): error C2899: typename cannot be used outside 
 a template declaration
 ..\string_algo_test.cpp(21): error C2899: typename cannot be used outside 
 a template declaration
 ..\string_algo_test.cpp(21): error C2899: typename cannot be used outside 
 a template declaration
 Tool: vc/7
 ..\string_algo_test.cpp(15): fatal error C1507: previous user errors and 
 subsequent error recovery halt further compilation
 Tool: vc/7.1
 Tool: vc/8
Mar 31 2005
parent "Matthew" <admin stlsoft.dot.dot.dot.dot.org> writes:
"Pablo Aguilar" <paguilarg hotmail.com> wrote in message
news:d2hvii$248v$1 digitaldaemon.com...

 Great!

 You tweaked first it right? I very much doubt it would've compiled that
cleanly on all compilers!


Barely


 Handy tool Arturius, BTW...


Yes. I *really* need to get it out to the world. ;$
Mar 31 2005
prev sibling next sibling parent reply "Matthew" <admin stlsoft.dot.dot.dot.dot.org> writes:
I've rewritten to try and get around VC6. But the following still ICEs

    template<ss_typename_param_k T>
    struct string_traits_
    {
        typedef typename T::value_type  char_type;
        typedef typename T::size_type   size_type;

        static char_type const  *get_data(T const &s)
        {
            return s.data();
        }
        static size_type        get_length(T const &s)
        {
            return s.size();
        }
    };

    template<>
    struct string_traits_<char const*>
    {
        typedef char            char_type;
        typedef size_t          size_type;

        static char_type const *get_data(char_type const *s)
        {
            return s;
        }
        static size_type        get_length(char_type const *s)
        {
            return strlen(s);
        }
    };

    template<>
    struct string_traits_<wchar_t const*>
    {
        typedef wchar_t         char_type;
        typedef size_t          size_type;

        static char_type const *get_data(char_type const *s)
        {
            return s;
        }
        static size_type        get_length(char_type const *s)
        {
            return wcslen(s);
        }
    };

    template<ss_typename_param_k S>
    const ::stlsoft::basic_string_view<ss_typename_type_k
string_traits_<S>::char_type> right_view(S const &s, 
ss_typename_type_k string_traits_<S>::size_type n)
    {
        typedef string_traits_<S>                       traits_t;
        typedef traits_t::char_type                     char_t;
        typedef traits_t::size_type                     size_t;
        typedef ::stlsoft::basic_string_view<char_t>    string_view_t;

        char_t const    *data   =   traits_t::get_data(s);
        const size_t    len     =   c_str_len(s);///* traits_t::get_length(s)
*/0;

        if(n > len)
        {
            n = len;
        }

        return string_view_t(data + (len - n), n);
    }
Mar 31 2005
parent reply "Pablo Aguilar" <paguilarg hotmail.com> writes:
"Matthew" <admin stlsoft.dot.dot.dot.dot.org> wrote in message 
news:d2i0mf$258r$1 digitaldaemon.com...

 I've rewritten to try and get around VC6. But the following still ICEs

    template<ss_typename_param_k T>
    struct string_traits_
    {
        typedef typename T::value_type  char_type;
        typedef typename T::size_type   size_type;

        static char_type const  *get_data(T const &s)
        {
            return s.data();
        }
        static size_type        get_length(T const &s)
        {
            return s.size();
        }
    };


Do you not use your ss_typename_type_k define for char_type and size_type?


    template<>
    struct string_traits_<char const*>
    {
        typedef char            char_type;
        typedef size_t          size_type;

        static char_type const *get_data(char_type const *s)
        {
            return s;
        }
        static size_type        get_length(char_type const *s)
        {
            return strlen(s);
        }
    };

    template<>
    struct string_traits_<wchar_t const*>
    {
        typedef wchar_t         char_type;
        typedef size_t          size_type;

        static char_type const *get_data(char_type const *s)
        {
            return s;
        }
        static size_type        get_length(char_type const *s)
        {
            return wcslen(s);
        }
    };


    template<ss_typename_param_k S>
    const ::stlsoft::basic_string_view<ss_typename_type_k 
 string_traits_<S>::char_type> right_view(S const &s, ss_typename_type_k 
 string_traits_<S>::size_type n)
    {
        typedef string_traits_<S>                       traits_t;
        typedef traits_t::char_type                     char_t;
        typedef traits_t::size_type                     size_t;
        typedef ::stlsoft::basic_string_view<char_t>    string_view_t;

        char_t const    *data   =   traits_t::get_data(s);
        const size_t    len     =   c_str_len(s);///* 
 traits_t::get_length(s) */0;

        if(n > len)
        {
            n = len;
        }

        return string_view_t(data + (len - n), n);
    }


Where's the ICE happening?

Pablo
Mar 31 2005
parent "Matthew" <admin stlsoft.dot.dot.dot.dot.org> writes:
"Pablo Aguilar" <paguilarg hotmail.com> wrote in message
news:d2i17r$25l5$1 digitaldaemon.com...

 "Matthew" <admin stlsoft.dot.dot.dot.dot.org> wrote in message
news:d2i0mf$258r$1 digitaldaemon.com...

 I've rewritten to try and get around VC6. But the following still ICEs

    template<ss_typename_param_k T>
    struct string_traits_
    {
        typedef typename T::value_type  char_type;
        typedef typename T::size_type   size_type;

        static char_type const  *get_data(T const &s)
        {
            return s.data();
        }
        static size_type        get_length(T const &s)
        {
            return s.size();
        }
    };


 Do you not use your ss_typename_type_k define for char_type and size_type?


    template<>
    struct string_traits_<char const*>
    {
        typedef char            char_type;
        typedef size_t          size_type;

        static char_type const *get_data(char_type const *s)
        {
            return s;
        }
        static size_type        get_length(char_type const *s)
        {
            return strlen(s);
        }
    };

    template<>
    struct string_traits_<wchar_t const*>
    {
        typedef wchar_t         char_type;
        typedef size_t          size_type;

        static char_type const *get_data(char_type const *s)
        {
            return s;
        }
        static size_type        get_length(char_type const *s)
        {
            return wcslen(s);
        }
    };


    template<ss_typename_param_k S>
    const ::stlsoft::basic_string_view<ss_typename_type_k
string_traits_<S>::char_type> right_view(S const &s, 
 ss_typename_type_k string_traits_<S>::size_type n)
    {
        typedef string_traits_<S>                       traits_t;
        typedef traits_t::char_type                     char_t;
        typedef traits_t::size_type                     size_t;
        typedef ::stlsoft::basic_string_view<char_t>    string_view_t;

        char_t const    *data   =   traits_t::get_data(s);
        const size_t    len     =   c_str_len(s);///* traits_t::get_length(s)
*/0;

        if(n > len)
        {
            n = len;
        }

        return string_view_t(data + (len - n), n);
    }


 Where's the ICE happening?


It says the source line is the end of run_test(). But that's not exactly
definitive. It's an attempt to instantiate 
a/the template within that fn, methinks.

Anyway, 't'is now fixed. :-)
Mar 31 2005
prev sibling next sibling parent "Matthew" <admin stlsoft.dot.dot.dot.dot.org> writes:
Tried using non-template overloads for the char/wchar_t. Still ICEs

#if 0
    template<typename CHAR_TYPE>
    stlsoft_ns_qual(basic_string_view)<CHAR_TYPE>
    right_view(
         CHAR_TYPE const* str
       , size_t cch
    )
    {
       typedef stlsoft_ns_qual(basic_string_view)<CHAR_TYPE> string_view_t;

       size_t size = ::stlsoft::c_str_len(str);
       return (size <= cch)
           ? string_view_t(str, cch)
           : string_view_t(str + (size - cch), cch)
           ;
    }
#else

    stlsoft_ns_qual(basic_string_view)<char> right_view(char const *str, size_t
cch)
    {
       typedef stlsoft_ns_qual(basic_string_view)<char> string_view_t;

       size_t size = ::stlsoft::c_str_len(str);
       return (size <= cch)
           ? string_view_t(str, cch)
           : string_view_t(str + (size - cch), cch)
           ;
    }

    stlsoft_ns_qual(basic_string_view)<wchar_t> right_view(wchar_t const *str,
size_t cch)
    {
       typedef stlsoft_ns_qual(basic_string_view)<wchar_t> string_view_t;

       size_t size = ::stlsoft::c_str_len(str);
       return (size <= cch)
           ? string_view_t(str, cch)
           : string_view_t(str + (size - cch), cch)
           ;
    }

#endif /* 0 */
Mar 31 2005
prev sibling parent reply "Matthew" <admin stlsoft.dot.dot.dot.dot.org> writes:
Success!!!

Please don't ask me why this works, but it does. Clean-compiles in Arturius
with all the previously mentioned compilers: 
:-)

    template <ss_typename_param_k S>
    struct right_view_traits
    {
        typedef S                                           string_type;
        typedef ss_typename_type_k string_type::value_type  char_type;
        typedef ::stlsoft::basic_string_view<char_type>     view_type;
    };

    template <>
    struct right_view_traits<char const *>
    {
        typedef char                                        char_type;
        typedef ::stlsoft::basic_string_view<char_type>     view_type;
    };

    template <>
    struct right_view_traits<wchar_t const *>
    {
        typedef wchar_t                                     char_type;
        typedef ::stlsoft::basic_string_view<char_type>     view_type;
    };

    ::stlsoft::basic_string_view<char>                  right_view(char const
*s, size_t n)
    {
        const size_t    len =   ::stlsoft::c_str_len(s);

        if(n > len)
        {
            // Want more than is available, so get all, from start
            n = len;
        }
        else
        {
            // Want less than is available, so get n from end
            s += (len - n);
        }

        return ::stlsoft::basic_string_view<char>(s, n);
    }

    ::stlsoft::basic_string_view<wchar_t>               right_view(wchar_t
const *s, size_t n)
    {
        const size_t    len =   ::stlsoft::c_str_len(s);

        if(n > len)
        {
            // Want more than is available, so get all, from start
            n = len;
        }
        else
        {
            // Want less than is available, so get n from end
            s += (len - n);
        }

        return ::stlsoft::basic_string_view<wchar_t>(s, n);
    }

    template <ss_typename_param_k S>
    ss_typename_type_k right_view_traits<S>::view_type  right_view(S const &s,
size_t n)
    {
        typedef right_view_traits<S>    traits_t;

        const size_t    len =   ::stlsoft::c_str_len(s);
        size_t          off =   0;

        if(n > len)
        {
            // Want more than is available, so get all, from start
            n = len;
        }
        else
        {
            off = len - n;
        }

        return traits_t::view_type(s.data() + off, n);
    }
Mar 31 2005
parent reply "Matthew" <admin stlsoft.dot.dot.dot.dot.org> writes:
Slightly better version:

    template <ss_typename_param_k S>
    struct right_view_traits
    {
        typedef S                                           string_type;
        typedef ss_typename_type_k string_type::value_type  char_type;
        typedef ::stlsoft::basic_string_view<char_type>     view_type;
    };

    template <>
    struct right_view_traits<char const *>
    {
        typedef char                                        char_type;
        typedef ::stlsoft::basic_string_view<char_type>     view_type;
    };

    template <>
    struct right_view_traits<wchar_t const *>
    {
        typedef wchar_t                                     char_type;
        typedef ::stlsoft::basic_string_view<char_type>     view_type;
    };

    template <ss_typename_param_k C>
    ::stlsoft::basic_string_view<C>                     right_view_helper(C
const *s, size_t n)
    {
        const size_t    len =   ::stlsoft::c_str_len(s);

        if(n > len)
        {
            // Want more than is available, so get all, from start
            n = len;
        }
        else
        {
            // Want less than is available, so get n from end
            s += (len - n);
        }

        return ::stlsoft::basic_string_view<C>(s, n);
    }

    ::stlsoft::basic_string_view<char>                  right_view(char const
*s, size_t n)
    {
        return right_view_helper(s, n);
    }

    ::stlsoft::basic_string_view<wchar_t>               right_view(wchar_t
const *s, size_t n)
    {
        return right_view_helper(s, n);
    }

    template <ss_typename_param_k S>
    ss_typename_type_k right_view_traits<S>::view_type  right_view(S const &s,
size_t n)
    {
        typedef right_view_traits<S>    traits_t;

        const size_t    len =   ::stlsoft::c_str_len(s);
        size_t          off =   0;

        if(n > len)
        {
            // Want more than is available, so get all, from start
            n = len;
        }
        else
        {
            off = len - n;
        }

        return traits_t::view_type(s.data() + off, n);
    }



Note that I've been thinking of adding a c_str_data() shim to STLSoft for some
time, partly related to string_view, and 
this definitely calls for it. Then the last line of the template version of
right_view would be far more generally 
applicable.
Mar 31 2005
parent reply "Pablo Aguilar" <paguilarg hotmail.com> writes:
So now all that's left of my code is but a memory... <g>
Can I take this and make left$ and mid$ or do you still have some more 
tweaking to do?

"Matthew" <admin stlsoft.dot.dot.dot.dot.org> wrote in message 
news:d2i257$26ag$1 digitaldaemon.com...

 Slightly better version:

    template <ss_typename_param_k S>
    struct right_view_traits
    {
        typedef S                                           string_type;
        typedef ss_typename_type_k string_type::value_type  char_type;
        typedef ::stlsoft::basic_string_view<char_type>     view_type;
    };

    template <>
    struct right_view_traits<char const *>
    {
        typedef char                                        char_type;
        typedef ::stlsoft::basic_string_view<char_type>     view_type;
    };

    template <>
    struct right_view_traits<wchar_t const *>
    {
        typedef wchar_t                                     char_type;
        typedef ::stlsoft::basic_string_view<char_type>     view_type;
    };

    template <ss_typename_param_k C>
    ::stlsoft::basic_string_view<C>                     right_view_helper(C 
 const *s, size_t n)
    {
        const size_t    len =   ::stlsoft::c_str_len(s);

        if(n > len)
        {
            // Want more than is available, so get all, from start
            n = len;
        }
        else
        {
            // Want less than is available, so get n from end
            s += (len - n);
        }

        return ::stlsoft::basic_string_view<C>(s, n);
    }

    ::stlsoft::basic_string_view<char>                  right_view(char 
 const *s, size_t n)
    {
        return right_view_helper(s, n);
    }

    ::stlsoft::basic_string_view<wchar_t>               right_view(wchar_t 
 const *s, size_t n)
    {
        return right_view_helper(s, n);
    }

    template <ss_typename_param_k S>
    ss_typename_type_k right_view_traits<S>::view_type  right_view(S const 
 &s, size_t n)
    {
        typedef right_view_traits<S>    traits_t;

        const size_t    len =   ::stlsoft::c_str_len(s);
        size_t          off =   0;

        if(n > len)
        {
            // Want more than is available, so get all, from start
            n = len;
        }
        else
        {
            off = len - n;
        }

        return traits_t::view_type(s.data() + off, n);
    }



 Note that I've been thinking of adding a c_str_data() shim to STLSoft for 
 some time, partly related to string_view, and this definitely calls for 
 it. Then the last line of the template version of right_view would be far 
 more generally applicable.
Mar 31 2005
parent "Matthew" <admin stlsoft.dot.dot.dot.dot.org> writes:
"Pablo Aguilar" <paguilarg hotmail.com> wrote in message
news:d2i38a$279u$1 digitaldaemon.com...

 So now all that's left of my code is but a memory... <g>


Hope not. I tried to stick close to it, but VC6 is a harsh mistress. ;)


 Can I take this and make left$ and mid$ or do you still have some more
 tweaking to do?


Nope. It's all yours. (I've sent you an email discussing various things, so
I'll let you read that and get back to me at 
your leisure.)

Thanks for the interest, and effort in exercising string_view. (Note: there's a
slight mod that you'll need *now*; see 
attached)

Cheers

Matthew



 "Matthew" <admin stlsoft.dot.dot.dot.dot.org> wrote in message
 news:d2i257$26ag$1 digitaldaemon.com...

 Slightly better version:

    template <ss_typename_param_k S>
    struct right_view_traits
    {
        typedef S                                           string_type;
        typedef ss_typename_type_k string_type::value_type  char_type;
        typedef ::stlsoft::basic_string_view<char_type>     view_type;
    };

    template <>
    struct right_view_traits<char const *>
    {
        typedef char                                        char_type;
        typedef ::stlsoft::basic_string_view<char_type>     view_type;
    };

    template <>
    struct right_view_traits<wchar_t const *>
    {
        typedef wchar_t                                     char_type;
        typedef ::stlsoft::basic_string_view<char_type>     view_type;
    };

    template <ss_typename_param_k C>
    ::stlsoft::basic_string_view<C>                     right_view_helper(C
 const *s, size_t n)
    {
        const size_t    len =   ::stlsoft::c_str_len(s);

        if(n > len)
        {
            // Want more than is available, so get all, from start
            n = len;
        }
        else
        {
            // Want less than is available, so get n from end
            s += (len - n);
        }

        return ::stlsoft::basic_string_view<C>(s, n);
    }

    ::stlsoft::basic_string_view<char>                  right_view(char
 const *s, size_t n)
    {
        return right_view_helper(s, n);
    }

    ::stlsoft::basic_string_view<wchar_t>               right_view(wchar_t
 const *s, size_t n)
    {
        return right_view_helper(s, n);
    }

    template <ss_typename_param_k S>
    ss_typename_type_k right_view_traits<S>::view_type  right_view(S const
 &s, size_t n)
    {
        typedef right_view_traits<S>    traits_t;

        const size_t    len =   ::stlsoft::c_str_len(s);
        size_t          off =   0;

        if(n > len)
        {
            // Want more than is available, so get all, from start
            n = len;
        }
        else
        {
            off = len - n;
        }

        return traits_t::view_type(s.data() + off, n);
    }



 Note that I've been thinking of adding a c_str_data() shim to STLSoft for
 some time, partly related to string_view, and this definitely calls for
 it. Then the last line of the template version of right_view would be far
 more generally applicable.


 



begin 666 string_view.hpp
M+RH +R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O
M+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\-"B J($9I;&4Z
M("  ("  ("!S=&QS;V9T+W-T<FEN9U]V:65W+FAP< T*("H-"B J(%!U<G!O



M;'-S;VX 86YD(%-C;W1T(%!A='1E<G-O;B!F;W( 9&ES8W5S<VEO;G, ;VX 
M=F%R:6]U<PT*("H ("  ("  ("  ("  (&YA;6EN9R!A;F0 9&5S:6=N(&ES

M("  ("  ("  ("  :&ES(&5A9VQE(&5Y960 <F5V:65W<R!O9B!B971A(&-O
M9&4N(#HM*0T*("H-"B J($AO;64Z("  ("  ("!H='1P.B\O<W1L<V]F="YO


M<V5R=F5D+ T*("H-"B J(%)E9&ES=')I8G5T:6]N(&%N9"!U<V4 :6X <V]U
M<F-E(&%N9"!B:6YA<GD 9F]R;7,L('=I=&  ;W( =VET:&]U= T*("H ;6]D
M:69I8V%T:6]N+"!A<F4 <&5R;6ET=&5D('!R;W9I9&5D('1H870 =&AE(&9O

M:6)U=&EO;G, ;V8 <V]U<F-E(&-O9&4 ;75S="!R971A:6X =&AE(&%B;W9E
M(&-O<'ER:6=H="!N;W1I8V4L('1H:7,-"B J("  ;&ES="!O9B!C;VYD:71I

M=')I8G5T:6]N<R!I;B!B:6YA<GD 9F]R;2!M=7-T(')E<')O9'5C92!T:&4 
M86)O=F4 8V]P>7)I9VAT(&YO=&EC92P-"B J("  =&AI<R!L:7-T(&]F(&-O
M;F1I=&EO;G, 86YD('1H92!F;VQL;W=I;F< 9&ES8VQA:6UE<B!I;B!T:&4 
M9&]C=6UE;G1A=&EO; T*("H ("!A;F0O;W( ;W1H97( ;6%T97)I86QS('!R
M;W9I9&5D('=I=&  =&AE(&1I<W1R:6)U=&EO;BX-"B J("T 3F5I=&AE<B!T
M:&4 ;F%M92AS*2!O9B!-871T:&5W(%=I;'-O;B!A;F0 4WEN97-I<R!3;V9T

M;6%Y(&)E('5S960 =&\ 96YD;W)S92!O<B!P<F]M;W1E('!R;V1U8W1S(&1E
M<FEV960 9G)O;0T*("H ("!T:&ES('-O9G1W87)E('=I=&AO=70 <W!E8VEF
M:6, <')I;W( =W)I='1E;B!P97)M:7-S:6]N+ T*("H-"B J(%1(25, 4T]&
M5%=!4D4 25, 4%)/5DE$140 0ED 5$A%($-/4%E224=(5"!(3TQ$15)3($%.


M140 5$\L(%1(10T*("H 24U03$E%1"!705)204Y42453($]&($U%4D-(04Y4
M04))3$E462!!3D0 1DE43D534R!&3U( 02!005)424-53$%2(%!54E!/4T4-

M65))1TA4($]73D52($]2($-/3E1224)55$]24R!"10T*("H 3$E!0DQ%($9/

M15A%35!,05)9+"!/4 T*("H 0T].4T51545.5$E!3"!$04U!1T53("A)3D-,
M541)3D<L($)55"!.3U0 3$E-251%1"!43RP 4%)/0U5214U%3E0 3T8-"B J

M051!+"!/4B!04D]&2513.R!/4B!"55-)3D534PT*("H 24Y415)255!424].
M*2!(3U=%5D52($-!55-%1"!!3D0 3TX 04Y9(%1(14]262!/1B!,24%"24Q)
M5%DL(%=(151(15( 24X-"B J($-/3E1204-4+"!35%))0U0 3$E!0DE,2519


M4R!33T945T%212P 159%3B!)1B!!1%9)4T5$($]&(%1(10T*("H 4$]34TE"

M+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O

M;F=?=FEE=RYH<' -"B\O+PT*+R\O(&)A<VEC7W-T<FEN9U]V:65W(&-L87-S

M15<-"B-D969I;F4 4U1,4T]&5%])3D-,7TA?4U1,4T]&5%]35%))3D=?5DE%

M5$E/3 T*(R!D969I;F4 4U1,4T]&5%]615)?2%]35$Q33T947U-44DE.1U]6


M4E](7U-43%-/1E1?4U1224Y'7U9)15=?4D5625-)3TX ,PT*(R!D969I;F4 



M+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O

M:65S+7-T87)T70T*7U]35$Q33T947T-/35!)3$527TE37TU715)+4SH 7U]-

M"B\J("\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O


M(R!I;F-L=61E(")S=&QS;V9T+F B("  ("  ("  ("  ("  ("  ("\O($EN
M8VQU9&4 =&AE(%-43%-O9G0 <F]O="!H96%D97(-"B-E;F1I9B O*B A4U1,

M3%](7U-43%-/1E1?05543U]"549&15(-"B, :6YC;'5D92 B<W1L<V]F=%]A
M=71O7V)U9F9E<BYH(B  ("  (" O+R!S=&QS;V9T.CIA=71O7V)U9F9E< T*
M(V5N9&EF("\J("%35$Q33T947TE.0TQ?2%]35$Q33T947T%55$]?0E5&1D52

M051/4 T*(R!I;F-L=61E(")S=&QS;V9T7VYE=U]A;&QO8V%T;W(N:"( ("  
M("\O('-T;'-O9G0Z.FYE=U]A;&QO8V%T;W(-"B-E;F1I9B O*B A4U1,4T]&


M<W1L<V]F=%]C:&%R7W1R86ET<RYH(B  ("  ("\O('-T;'-O9G0Z.F-H87)?

M4E]44D%)5%, *B\-"B-I9FYD968 4U1,4T]&5%])3D-,7TA?4U1,4T]&5%])
M5$52051/4 T*(R!I;F-L=61E(")S=&QS;V9T7VET97)A=&]R+F B("  ("  
M("  ("\O('-T;'-O9G0 :71E<F%T;W( 8F%S97,-"B-E;F1I9B O*B A4U1,

M+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O

M" T*(VEF;F1E9B!?4U1,4T]&5%].3U].04U%4U!!0T4-"FYA;65S<&%C92!S



M+R!<=V5A:V=R;W5P(&QI8G)A<FEE<R!35$Q3;V9T($QI8G)A<FEE<PT*+R\O
M(%QB<FEE9B!4:&4 :6YD:79I9'5A;"!L:6)R87)I97,-" T*+R\O(%QW96%K
M9W)O=7  ;&EB<F%R:65S7W-T<FEN9R!3=')I;F< 3&EB<F%R>0T*+R\O(%QI
M;F=R;W5P(&QI8G)A<FEE<PT*+R\O(%QB<FEE9B!4:&ES(&QI8G)A<GD <')O
M=FED97, 9F%C:6QI=&EE<R!F;W( 9&5F:6YI;F< 86YD(&UA;FEP=6QA=&EN



M<F%R>2!P<F]V:61E<R!F86-I;&ET:65S(&9O<B!D969I;FEN9R!A;F0 ;6%N

M+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O


M="!H;VQD<R!N;R!I;G1E<FYA;"!S=&]R86=E+"!A;F0 ;65R96QY(')E<')E
M<V5N=', 82!W:6YD;W< :6YT;R!O=&AE<B!S=')I;F< <W1O<F%G90T*+R\O

M(%0 5&AE('1R86ET<R!T>7!E+B!/;B!T<F%N<VQA=&]R<R!T:&%T('-U<'!O
M<G0 9&5F875L="!T96UP;&%T92!A<F=U;65N=', =&AI<R!I<R!D969A=6QT
M960 =&\ 8VAA<E]T<F%I=',\0SX-"B\O+R!<<&%R86T 02!4:&4 86QL;V-A
M=&]R('1Y<&4N($]N('1R86YS;&%T;W)S('1H870 <W5P<&]R="!D969A=6QT
M('1E;7!L871E(&%R9W5M96YT<R!T:&ES(&ES(&1E9F%U;'1E9"!T;R!N97=?
M86QL;V-A=&]R/$,^+B!4:&ES(&ES(&]N;'D =7-E9"!B>2!T:&4 <')O>'D 
M9V5N97)A=&5D(&)Y(&-?<W1R*"D-"G1E;7!L871E/"  ('-S7W1Y<&5N86UE

M4U]$149!54Q47T-,05-37T%21U5-14Y47U-54%!/4E0-"B  ("  ("  +"  

M("  ("P ("!S<U]T>7!E;F%M95]P87)A;5]K($$ /2!N97=?86QL;V-A=&]R

M("\J(#T 8VAA<E]T<F%I=',\0SX *B\-"B  ("  ("  +"  ('-S7W1Y<&5N
M86UE7W!A<F%M7VL 02 O*B ](&YE=U]A;&QO8V%T;W(\0SX *B\-"B-E;F1I





M('1Y<&5D968 5"  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("!T<F%I

M961E9B!!("  ("  ("  ("  ("  ("  ("  ("  ("  ("  (&%L;&]C871O
M<E]T>7!E.PT*("  ("\O+R!4:&4 8W5R<F5N="!P87)A;65T97)I<V%T:6]N


M97( ='EP90T*("  ('1Y<&5D968 =F%L=65?='EP92  ("  ("  ("  ("  




M9B!V86QU95]T>7!E(&-O;G-T("  ("  ("  ("  ("  ("IC;VYS=%]P;VEN

M='EP961E9B!V86QU95]T>7!E("  ("  ("  ("  ("  ("  ("  ("9R969E

M;&4 *&-O;G-T*2!R969E<F5N8V4 ='EP90T*("  ('1Y<&5D968 =F%L=65?
M='EP92!C;VYS="  ("  ("  ("  ("  (" F8V]N<W1?<F5F97)E;F-E.PT*

M("  ("  ("  ("  ("  ("  ("  ('-I>F5?='EP93L-"B  (" O+R\ 5&AE
M(&1I9F9E<F5N8V4 ='EP90T*("  ('1Y<&5D968 <W-?<'1R9&EF9E]T("  



M("  ("!S<U]T>7!E;F%M95]T>7!E7VL-"B-E;F1I9B O*B!?7U-43%-/1E1?
M0T]-4$E,15)?25-?0D]23$%.1" J+PT*("  ("  ("  ("  ("  ("  ("  
M("!P;VEN=&5R7VET97)A=&]R(#P
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  +"  ('!O:6YT97(-"B  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  (" L("  <F5F

M("  /CHZ:71E<F%T;W)?='EP92  ("!I=&5R871O<CL-"B-E;F1I9B O*B P


M3TU024Q%4E])4U]"3U),04Y$*0T*("  ("  ("  <W-?='EP96YA;65?='EP

M*B\-"B  ("  ("  ("  ("  ("  ("  ("  <&]I;G1E<E]I=&5R871O<B \
M("  =F%L=65?='EP92!C;VYS= T*("  ("  ("  ("  ("  ("  ("  ("  

M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  +"  (&-O;G-T7W)E9F5R
M96YC90T*("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  
M(#XZ.FET97




M("  ("  ("  +"  ('9A;'5E7W1Y<&4-"B  ("  ("  ("  ("  ("  ("  

M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  +"  ('!O:6YT97(-"B  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  (" L("  9&EF

M("  ("  ("  /B  ("  ("  ("  ("  ("  ("!R979E<G-E7VET97)A=&]R


M;VYS=%]R979E<G-E7VET97)A=&]R7V)A<V4 /"  (&-O;G-T7VET97)A=&]R

M('9A;'5E7W1Y<&4 8V]N<W0-"B  ("  ("  ("  ("  ("  ("  ("  ("  

M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  +"  (&-O;G-T7W!O:6YT
M97(-"B  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  (" L

M("  ("  ("  ("  ("  /B  ("  ("  ("  ("  ("  ("!C;VYS=%]R979E

M5$E/3D%,7TE415)!5$]27U-54%!/4E0 *B\-" T*+R\O(%QN86UE($-O;G-T



M='EP92!C;VYS=" F<FAS*3L-"B  (" O+R\ 0V]N<W1R=6-T(&9R;VT =&AE

M8F%S:6-?<W1R:6YG7W9I97<H8VQA<W-?='EP92!C;VYS=" F<RP <VEZ95]T

M86-T97)S(&9R;VT =&AE(&=I=F5N('-T<FEN9R!A="!T:&4 <W!E8VEF:65D


M+R\O($-O;G-T<G5C="!F<F]M(&$ ;G5L;"UT97)M:6YA=&5D(&-H87)A8W1E
M<B!S=')I;F<-"B  ("!B87-I8U]S=')I;F=?=FEE=RAC:&%R7W1Y<&4 8V]N

M;VYS=')U8W0 =VET:"!<8R!C8V  8VAA<F%C=&5R<R!F<F]M('1H92!G:79E

M<E]T>7!E(&-O;G-T("IS+"!S:7IE7W1Y<&4 8V-H*3L-"B  (" O+R\ 0V]N
M<W1R=6-T(&9R;VT =&AE(')A;F=E(%MF:7)S=#IL87-T*0T*(VEF("%D969I



M("  =&5M<&QA=&4 /'-S7W1Y<&5N86UE7W!A<F%M7VL 4D%)/ T*("  (&)A

M(#H ;5]L96YG=& H;&%S=" M(&9I<G-T*0T*("  ("  (" L(&U?8F%S92AF

M('-T;'-O9G1?87-S97)T*&9I<G-T(#P
M;'-O9G1?87-S97)T*&ES7W9A;&ED*"DI.PT*("  ('T-"B-E;F1I9B O*B!?
M7U-43%-/1E1?0T9?345-0D527U1%35!,051%7U)!3D=%7TU%5$A/1%]355!0


M;VT 86X 87)R87D-"B  ("!T96UP;&%T92 \<W-?='EP96YA;65?<&%R86U?
M:R!$+"!S<U]S:7IE7W0 3CX-"B  ("!S<U]E>'!L:6-I=%]K(&)A<VEC7W-T
M<FEN9U]V:65W*$0 *"9D*5M.72D-"B  ("  ("  .B!M7VQE;F=T:"A.*0T*
M("  ("  (" L(&U?8F%S92 F9%LP72D-"B  ("  ("  +"!M7V-S='(H3E5,

M05E?4TE:15]$151%4DU)3D%424].7U-54%!/4E0 *B\-"B  (" O+R\ 1&5S


M+R\ 4W=A<', =&AE(&-O;G1E;G1S(&)E='=E96X 7&, =&AI<R!A;F0 7&, 

M("  +R\O($5M<'1I97, =&AE('-T<FEN9PT*("  ('9O:60 8VQE87(H*3L-



M92!M87AI;75M(&YU;6)E<B!O9B!E;&5M96YT<R!T:&%T(&-A;B!B92!S=&]R
M960 :6X =&AE('-T<FEN9PT*("  ('-T871I8R!S:7IE7W1Y<&4 ;6%X7W-I
M>F4H*3L-"B  (" O+R\ 5&AE(&YU;6)E<B!O9B!E;&5M96YT<R!I;B!T:&4 

M+R!4:&4 <W1O<F%G92!C=7)R96YT;'D 86QL;V-A=&5D(&)Y('1H92!S=')I
M;F<-"B  ("!S:7IE7W1Y<&4 8V%P86-I='DH*2!C;VYS=#L-"B  (" O+R\ 
M26YD:6-A=&5S('=H971H97( =&AE('-T<FEN9R!I<R!E;7!T>0T*("  ('-S




M($5V86QU871E<R!W:&5T:&5R('1W;R!S=')I;F=S(&%R92!E<75A; T*("  
M('-S7V)O;VQ?="!E<75A;"AV86QU95]T>7!E(&-O;G-T("IR:',L('-I>F5?


M<F4H<VEZ95]T>7!E('!O<RP <VEZ95]T>7!E(&-C:"P =F%L=65?='EP92!C


M<VEN=%]T(&-O;7!A<F4H<VEZ95]T>7!E('!O<RP <VEZ95]T>7!E(&-C:"P 




M<W-?<VEN=%]T(&-O;7!A<F4H<VEZ95]T>7!E('!O<RP <VEZ95]T>7!E(&-C
M:"P 8VQA<W-?='EP92!C;VYS=" F<FAS+"!S:7IE7W1Y<&4 <&]S4FAS+"!S
M:7IE7W1Y<&4 8V-H4FAS*2!C;VYS=#L-"B  (" O+R\ 0V]M<&%R97, 7&, 
M=&AI<R!W:71H('1H92!G:79E;B!S=')I;F<-"B  ("!S<U]S:6YT7W0 8V]M
M<&%R92AS:7IE7W1Y<&4 <&]S+"!S:7IE7W1Y<&4 8V-H+"!C;&%S<U]T>7!E

M('=I=&  =&AE(&=I=F5N('-T<FEN9PT*("  ('-S7W-I;G1?="!C;VUP87)E


M("\O+R!2971U<FYS(&UU=&%B;&4 <F5F97)E;F-E(&%T('1H92!G:79E;B!I
M;F1E> T*("  (')E9F5R96YC92  ("  ("  ("  ("  (&]P97)A=&]R(%M=

M971U<FYS(&YO;BUM=71A8FQE("AC;VYS="D <F5F97)E;F-E(&%T('1H92!G
M:79E;B!I;F1E> T*("  (&-O;G-T7W)E9F5R96YC92  ("  ("  (&]P97)A

M=7)N<R!N=6QL+71E<FUI;F%T960 ;F]N+6UU=&%B;&4 *&-O;G-T*2!P;VEN



M='EP92!C;VYS="  ("  ("  *F1A=&$H*2!C;VYS=#L-
M(" O+R\ 4F5T=7)N<R!T:&4 9FER<W0 8VAA<F%C=&5R(&EN('1H92!S=')I
M;F<-"B  (" O+R\-"B  (" O+R\ 7&YO=&4 270 :7, =7  =&\ =&AE('5S
M97( =&\ 96YS=7)E('1H870 =&AE('-T<FEN9R!I<R!N;W0 96UP='D-"B  
M("!R969E<F5N8V4 ("  ("  ("  ("  ("!F<F]N=" I.PT*("  ("\O+R!2




M(" O+R\ 4F5T=7)N<R!T:&4 9FER<W0 8VAA<F%C=&5R(&EN('1H92!S=')I
M;F<-"B  (" O+R\-"B  (" O+R\ 7&YO=&4 270 :7, =7  =&\ =&AE('5S
M97( =&\ 96YS=7)E('1H870 =&AE('-T<FEN9R!I<R!N;W0 96UP='D-"B  
M("!C;VYS=%]R969E<F5N8V4 ("  ("  ("!F<F]N=" I(&-O;G-T.PT*("  
M("\O+R!2971U<FYS('1H92!L87-T(&-H87)A8W1E<B!I;B!T:&4 <W1R:6YG



M+R\O($-O<&EE<R!E;&5M96YT<R!I;G1O('1H92!G:79E;B!D97-T:6YA=&EO
M; T*("  ('-I>F5?='EP92!C;W!Y*'9A;'5E7W1Y<&4 *F1E<W0L('-I>F5?
M='EP92!C8V L('-I>F5?='EP92!P;W, /2 P*2!C;VYS=#L-"B\O+R! ?0T*

M+R\ 0F5G:6YS('1H92!I=&5R871I;VX-"B  (" O+R\-"B  (" O+R\ 7')E
M='5R;B!!(&YO;BUM=71A8FQE("AC;VYS="D :71E<F%T;W( <F5P<F5S96YT
M:6YG('1H92!S=&%R="!O9B!T:&4 <V5Q=65N8V4-"B  ("!C;VYS=%]I=&5R
M871O<B  ("  ("  ("!B96=I;B I(&-O;G-T.PT*("  ("\O+R!%;F1S('1H
M92!I=&5R871I;VX-"B  (" O+R\-"B  (" O+R\ 7')E='5R;B!!(&YO;BUM
M=71A8FQE("AC;VYS="D :71E<F%T;W( <F5P<F5S96YT:6YG('1H92!E;F0 


M=&EO; T*("  ("\O+PT*("  ("\O+R!<<F5T=7)N($%N(&ET97)A=&]R(')E

M<F%T;W( ("  ("  ("  ("  ("  8F5G:6XH*3L-"B  (" O+R\ 16YD<R!T




M3%])5$52051/4E]355!03U)4*0T*("  ("\O+R!"96=I;G, =&AE(')E=F5R

M;75T86)L92 H8V]N<W0I(&ET97)A=&]R(')E<')E<V5N=&EN9R!T:&4 <W1A
M<G0 ;V8 =&AE(')E=F5R<V4 <V5Q=65N8V4-"B  ("!C;VYS=%]R979E<G-E
M7VET97)A=&]R("!R8F5G:6XH*2!C;VYS=#L-"B  (" O+R\ 16YD<R!T:&4 
M<F5V97)S92!I=&5R871I;VX-"B  (" O+R\-"B  (" O+R\ 7')E='5R;B!!
M(&YO;BUM=71A8FQE("AC;VYS="D :71E<F%T;W( <F5P<F5S96YT:6YG('1H
M92!E;F0 ;V8 =&AE(')E=F5R<V4 <V5Q=65N8V4-"B  ("!C;VYS=%]R979E


M(%QR971U<FX 06X :71E<F%T;W( <F5P<F5S96YT:6YG('1H92!S=&%R="!O
M9B!T:&4 <F5V97)S92!S97%U96YC90T*("  (')E=F5R<V5?:71E<F%T;W( 
M("  ("  (')B96=I;B I.PT*("  ("\O+R!%;F1S('1H92!R979E<G-E(&ET
M97)A=&EO; T*("  ("\O+PT*("  ("\O+R!<<F5T=7)N($%N(&ET97)A=&]R
M(')E<')E<V5N=&EN9R!T:&4 96YD(&]F('1H92!R979E<G-E('-E<75E;F-E



M=F%R:6%N= T*(VEF9&5F(%-43%-/1E1?54Y)5%1%4U0-"G!U8FQI8SH-"B-E

M"B  ("!S<U]B;V]L7W0 :7-?=F%L:60H*2!C;VYS=#L-" T*+R\O(%QN86UE



M<U]S:6YT7W0 8V]M<&%R95\H8VAA<E]T>7!E(&-O;G-T("IL:',L('-I>F5?
M='EP92!L:'-?;&5N+"!C:&%R7W1Y<&4 8V]N<W0 *G)H<RP <VEZ95]T>7!E


M("  (&-H87)?='EP92!C;VYS=" J;5]B87-E.PT*("  (&-H87)?='EP92  

M+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O


M+R\ ;W!E<F%T;W( /3T-" T*=&5M<&QA=&4\("  <W-?='EP96YA;65?<&%R


M;FQI;F4 <W-?8F]O;%]T(&]P97)A=&]R(#T]*&)A<VEC7W-T<FEN9U]V:65W
M/$,L(%0L($$^(&-O;G-T("9L:',L(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L


M("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*("  ("  (" L("  


M7U-54%!/4E0-"FEN;&EN92!S<U]B;V]L7W0 ;W!E<F%T;W( /3TH8F%S:6-?
M<W1R:6YG7W9I97<\0RP 5"P 03X 8V]N<W0 )FQH<RP <W-?='EP96YA;65?
M='EP95]K(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIC:&%R7W1Y<&4 

M(#T]*&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^(&-O;G-T("9L:',L($, 
M8V]N<W0 *G)H<RD-"B-E;F1I9B O*B!?7U-43%-/1E1?0T9?5$5-4$Q!5$5?

M("!T>7!E9&5F('-S7W1Y<&5N86UE7W1Y<&5?:R!B87-I8U]S=')I;F=?=FEE

M='EP961E9B!S<U]T>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\

M("!S:7IE7W1Y<&4 ("!R:'-?;&5N(#T
M('1R86ET<U]T>7!E.CIL96YG=& H<FAS*3L-" T*("  (')E='5R;B!L:',N
M97%U86PH<FAS+"!R:'-?;&5N*3L-"GT-" T*=&5M<&QA=&4\("  <W-?='EP

M;5]K(%0-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 00T*("  


M(&]P97)A=&]R(#T]*'-S7W1Y<&5N86UE7W1Y<&5?:R!B87-I8U]S=')I;F=?




M7T-&7U1%35!,051%7T]55$]&0TQ!4U-&3E]154%,249)141?5%E015]355!0

M:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.G-I>F5?='EP92  ("  ("  <VEZ
M95]T>7!E.PT*("  ('1Y<&5D968 <W-?='EP96YA;65?='EP95]K(&)A<VEC
M7W-T<FEN9U]V:65W/$,L(%0L($$^.CIT<F%I='-?='EP92  ("  ('1R86ET





M("P ("!S<U]T>7!E;F%M95]P87)A;5]K($$-"B  ("  ("  / T*:6YL:6YE




M+"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*("  ("  (" L("  <W-?='EP


M4E0-"FEN;&EN92!S<U]B;V]L7W0 ;W!E<F%T;W( (3TH8F%S:6-?<W1R:6YG
M7W9I97<\0RP 5"P 03X 8V]N<W0 )FQH<RP <W-?='EP96YA;65?='EP95]K
M(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIC:&%R7W1Y<&4 8V]N<W0 

M<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^(&-O;G-T("9L:',L($, 8V]N<W0 

M3$%34T9.7U%504Q)1DE%1%]465!%7U-54%!/4E0 *B\-"GL-"B  ("!T>7!E


M9B!S<U]T>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 

M7W1Y<&4 ("!R:'-?;&5N(#T
M<U]T>7!E.CIL96YG=& H<FAS*3L-" T*("  (')E='5R;B A;&AS+F5Q=6%L

M87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*


M04Q)1DE%1%]465!%7U-54%!/4E0-"FEN;&EN92!S<U]B;V]L7W0 ;W!E<F%T
M;W( (3TH<W-?='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W/$,L
M(%0L($$^.CIC:&%R7W1Y<&4 8V]N<W0 *FQH<RP 8F%S:6-?<W1R:6YG7W9I

M;%]T(&]P97)A=&]R("$]*$, 8V]N<W0 *FQH<RP 8F%S:6-?<W1R:6YG7W9I
M97<\0RP 5"P 03X 8V]N<W0 )G)H<RD-"B-E;F1I9B O*B!?7U-43%-/1E1?

M4E0 *B\-"GL-"B  ("!T>7!E9&5F('-S7W1Y<&5N86UE7W1Y<&5?:R!B87-I


M<W1R:6YG7W9I97<\0RP 5"P 03XZ.G1R86ET<U]T>7!E("  ("  =')A:71S



M97)A=&]R(#P-


M<W-?8F]O;%]T(&]P97)A=&]R(#PH8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 
M03X 8V]N<W0 )FQH<RP 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03X 8V]N



M<U]T>7!E;F%M95]P87)A;5]K($$-"B  ("  ("  / T*(VEF9&5F(%]?4U1,

M4U504$]25 T*:6YL:6YE('-S7V)O;VQ?="!O<&5R871O<B \*&)A<VEC7W-T
M<FEN9U]V:65W/$,L(%0L($$^(&-O;G-T("9L:',L('-S7W1Y<&5N86UE7W1Y


M*&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^(&-O;G-T("9L:',L($, 8V]N
M<W0 *G)H<RD-"B-E;F1I9B O*B!?7U-43%-/1E1?0T9?5$5-4$Q!5$5?3U54


M('-S7W1Y<&5N86UE7W!A<F%M7VL 0PT*("  ("  (" L("  <W-?='EP96YA


M551/1D-,05-31DY?455!3$E&245$7U194$5?4U504$]25 T*:6YL:6YE('-S
M7V)O;VQ?="!O<&5R871O<B \*'-S7W1Y<&5N86UE7W1Y<&5?:R!B87-I8U]S


M:6YL:6YE('-S7V)O;VQ?="!O<&5R871O<B \*$, 8V]N<W0 *FQH<RP 8F%S
M:6-?<W1R:6YG7W9I97<\0RP 5"P 03X 8V]N<W0 )G)H<RD-"B-E;F1I9B O

M1%]465!%7U-54%!/4E0 *B\-"GL-"B  ("!R971U<FX <FAS+F-O;7!A<F4H

M('-S7W1Y<&5N86UE7W!A<F%M7VL 0PT*("  ("  (" L("  <W-?='EP96YA

M($$-"B  ("  ("  / T*:6YL:6YE('-S7V)O;VQ?="!O<&5R871O<B \/2AB


M;B!L:',N8V]M<&%R92AR:',I(#P
M>7!E;F%M95]P87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A

M("  ("  (#X-
M3$%34T9.7U%504Q)1DE%1%]465!%7U-54%!/4E0-"FEN;&EN92!S<U]B;V]L
M7W0 ;W!E<F%T;W( /#TH8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03X 8V]N
M<W0 )FQH<RP <W-?='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W

M;F4 <W-?8F]O;%]T(&]P97)A=&]R(#P]*&)A<VEC7W-T<FEN9U]V:65W/$,L
M(%0L($$^(&-O;G-T("9L:',L($, 8V]N<W0 *G)H<RD-"B-E;F1I9B O*B!?

M65!%7U-54%!/4E0 *B\-"GL-"B  ("!R971U<FX ;&AS+F-O;7!A<F4H<FAS



M7U]35$Q33T947T-&7U1%35!,051%7T]55$]&0TQ!4U-&3E]154%,249)141?


M8VAA<E]T>7!E(&-O;G-T("IL:',L(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L






M($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*("  ("  



M;VYS=" F<FAS*0T*>PT*("  (')E='5R;B!L:',N8V]M<&%R92AR:',I(#X 
M,#L-"GT-"G1E;7!L871E/"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 0PT*("  

M<U]T>7!E;F%M95]P87)A;5]K($$-"B  ("  ("  / T*(VEF9&5F(%]?4U1,

M4U504$]25 T*:6YL:6YE('-S7V)O;VQ?="!O<&5R871O<B ^*&)A<VEC7W-T
M<FEN9U]V:65W/$,L(%0L($$^(&-O;G-T("9L:',L('-S7W1Y<&5N86UE7W1Y


M*&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^(&-O;G-T("9L:',L($, 8V]N
M<W0 *G)H<RD-"B-E;F1I9B O*B!?7U-43%-/1E1?0T9?5$5-4$Q!5$5?3U54


M<U]T>7!E;F%M95]P87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE
M7W!A<F%M7VL 5 T*("  ("  (" L("  <W-?='EP96YA;65?<&%R86U?:R!!


M;V]L7W0 ;W!E<F%T;W( /BAS<U]T>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R
M:6YG7W9I97<\0RP 5"P 03XZ.F-H87)?='EP92!C;VYS=" J;&AS+"!B87-I



M7U]35$Q33T947T-&7U1%35!,051%7T]55$]&0TQ!4U-&3E]154%,249)141?


M<U]T>7!E;F%M95]P87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE
M7W!A<F%M7VL 5 T*("  ("  (" L("  <W-?='EP96YA;65?<&%R86U?:R!!

M:6-?<W1R:6YG7W9I97<\0RP 5"P 03X 8V]N<W0 )FQH<RP 8F%S:6-?<W1R
M:6YG7W9I97<\0RP 5"P 03X 8V]N<W0 )G)H<RD-"GL-"B  ("!R971U<FX 
M;&AS+F-O;7!A<F4H<FAS*2 ^/2 P.PT*?0T*=&5M<&QA=&4\("  <W-?='EP

M;5]K(%0-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 00T*("  


M(&]P97)A=&]R(#X]*&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^(&-O;G-T




M5$Q33T947T-&7U1%35!,051%7T]55$]&0TQ!4U-&3E]154%,249)141?5%E0

M/CT ,#L-"GT-"G1E;7!L871E/"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 0PT*

M("!S<U]T>7!E;F%M95]P87)A;5]K($$-"B  ("  ("  / T*(VEF9&5F(%]?

M4$5?4U504$]25 T*:6YL:6YE('-S7V)O;VQ?="!O<&5R871O<B ^/2AS<U]T
M>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.F-H

M/B!C;VYS=" F<FAS*0T*(V5L<V4-"FEN;&EN92!S<U]B;V]L7W0 ;W!E<F%T


M15]/551/1D-,05-31DY?455!3$E&245$7U194$5?4U504$]25" J+PT*>PT*
M("  (')E='5R;B!R:',N8V]M<&%R92AL:',I(#P
M9B O*B A7U]35$Q33T947T1/0U5-14Y4051)3TY?4TM)4%]314-424].("HO




M87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*

M"FEN;&EN92!3("9O<&5R871O<B \/"A3("8 <RP 8F%S:6-?<W1R:6YG7W9I
M97<\0RP 5"P 03X 8V]N<W0 )G-T<BD-"GL-"B  ("!S+G=R:71E*'-T<BYD

M+RH +R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O
M+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\-"B J(%5N:70M

M;65S<&%C92!U;FET=&5S= T*>PT*("  (&YA;65S<&%C90T*("  ('L-"B  
M("  ("  <W-?8F]O;%]T('1E<W1?<W1L<V]F=%]S=')I;F=?=FEE=RAU;FET
M=&5S=%]R97!O<G1E<B J<BD-"B  ("  ("  >PT*("  ("  ("  ("  <W-?

M"B  ("  ("  ("  ('5N:71T97-T7VEN:71I86QI<V5R("  (&EN:70H<BP 

M("  ("  ('1Y<&5D968 <W1L<V]F=%]N<U]Q=6%L*&)A<VEC7W-T<FEN9U]V
M:65W*3P 8VAA< T*("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  
M("  ("  ("  ("  ("  ("  ("P ("!C:&%R7W1R86ET<SQC:&%R/ T*("  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  

M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  /B  ("  ("!S

M6UT /2 B2&5L;&\ 3F%T='DA(CL-" T*("  ("  ("  ("  :68H(7-E9U]S

M("  ("  <BT^<F5P;W)T*")$969A=6QT(&-O;G-T<G5C=&EO;B!A;F0O;W( 

M("  ("  8E-U8V-E<W, /2!F86QS93L-"B  ("  ("  ("  ('T-" T*("  
M("  ("  ("  :68H<V5G7W-T<FEN9U]T*"D (3T <V5G7W-T<FEN9U]T*"DI

M969A=6QT(&-O;G-T<G5C=&EO;B!A;F0O;W( (3T 8V]M<&%R:7-O;B!F86EL

M86QS93L-"B  ("  ("  ("  ('T-" T*("  ("  ("  ("  <V5G7W-T<FEN

M("  ("  ("  ("!S96=?<W1R:6YG7W0 ("  <W,Q*"9S6S9=+" V*3L-"B  

M("  ("  ("  ("!I9BAS<S$ /#T <W,R*0T*("  ("  ("  ("  >PT*("  
M("  ("  ("  ("  ('(M/G)E<&]R=" B/#T 8V]M<&%R:7-O;B!F86EL960B

M93L-"B  ("  ("  ("  ('T-"B  ("  ("  ("  (&EF*'-S,B ^('-S,2D-
M"B  ("  ("  ("  ('L-"B  ("  ("  ("  ("  ("!R+3YR97!O<G0H(CX 

M("  8E-U8V-E<W, /2!F86QS93L-"B  ("  ("  ("  ('T-" T*("  ("  

M(F%B8R(I*0T*("  ("  ("  ("  >PT*("  ("  ("  ("  ("  ('(M/G)E

M("  ("  ("  8E-U8V-E<W, /2!F86QS93L-"B  ("  ("  ("  ('T-" T*

M+F-O;7!A<F4H,"P ,RP (F%B8R(I*0T*("  ("  ("  ("  >PT*("  ("  
M("  ("  ("  ('(M/G)E<&]R=" B8V]M<&%R92AP+"!C8V L(',I(&9A:6QE
M9"(L(%]?3$E.15]?*3L-"B  ("  ("  ("  ("  ("!B4W5C8V5S<R ](&9A



M("  <BT^<F5P;W)T*")C;VUP87)E*' L(&-C:"P <BP <G L(')N*2!F86EL

M86QS93L-"B  ("  ("  ("  ('T-" T*("  ("  ("  ("  <F5T=7)N(&)3

M<F%R("  ('5N:71T97-T7W-T;'-O9G1?<W1R:6YG7W9I97<H=&5S=%]S=&QS
M;V9T7W-T<FEN9U]V:65W*3L-"B  ("!]("\O(&%N;VYY;6]U<R!N86UE<W!A
M8V4-" T*?2 O+R!N86UE<W!A8V4 =6YI='1E<W0-" T*(V5N9&EF("\J(%-4
M3%-/1E1?54Y)5%1%4U0 *B\-" T*+RH +R\O+R\O+R\O+R\O+R\O+R\O+R\O
M+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O


M26UP;&5M96YT871I;VX-" T*=&5M<&QA=&4\("  <W-?='EP96YA;65?<&%R


M;FQI;F4 +RH <W1A=&EC("HO('-S7W1Y<&5N86UE7W1Y<&5?:R!B87-I8U]S


M+R\ 5&AI<R!C:&%R86-T97( 87)R87D :7, :6YI=&EA;&ES960 =&\ ,"P 
M=VAI8V  8V]N=F5N:65N=&QY(&AA<'!E;G, =&\-"B  (" O+R!B92!T:&4 
M96UP='D <W1R:6YG+"!B>2!T:&4 ;6]D=6QE+V%P<&QI8V%T:6]N(&QO860L





M<U]T>7!E;F%M95]P87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE
M7W!A<F%M7VL 5 T*("  ("  (" L("  <W-?='EP96YA;65?<&%R86U?:R!!

M<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIC;VUP87)E7R  <W-?='EP96YA
M;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIV86QU95]T
M>7!E(&-O;G-T("  *FQH<PT*("  ("  ("  ("  ("  ("  ("  ("  ("  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("P ("!S<U]T
M>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.G-I

M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  

M+"!!/CHZ=F%L=65?='EP92!C;VYS="  ("IR:',-"B  ("  ("  ("  ("  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  
M("  (" L("  <W-?='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W
M/$,L(%0L($$^.CIS:7IE7W1Y<&4 ("  ("  ("  <FAS7VQE;BD-"GL-"B  
M("!S:7IE7W1Y<&4 ("!C;7!?;&5N(#T (" H;&AS7VQE;B \(')H<U]L96XI

M(" ]("  =')A:71S7W1Y<&4Z.F-O;7!A<F4H;&AS+"!R:',L(&-M<%]L96XI

M;'0 /2!S=&%T:6-?8V%S=#QS<U]I;G1?=#XH;&AS7VQE;BD +2!S=&%T:6-?
M8V%S=#QS<U]I;G1?=#XH
M(')E<W5L=#L-
M<U]T>7!E;F%M95]P87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE
M7W!A<F%M7VL 5 T*("  ("  (" L("  <W-?='EP96YA;65?<&%R86U?:R!!

M97<\0RP 5"P 03XZ.FES7W9A;&ED*"D 8V]N<W0-"GL-"B  (" O+R!.3U1%
M.B!-=7-T(&YO="!C86QL(&%N>2!M971H;V1S(&]R(&-T;W)S(&EN('1H:7, 

M("  ($Y53$P (3T ;5]C<W1R*0T*("  ('L-"B  ("  ("  <F5T=7)N(&9A


M($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*("  ("  


M97<H*0T*("  (#H ;5]L96YG=& H,"D-"B  (" L(&U?8F%S92A.54Q,*0T*



M("  ("P ("!S<U]T>7!E;F%M95]P87)A;5]K($$-"B  ("  ("  / T*:6YL
M:6YE(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIB87-I8U]S=')I;F=?

M("  (#H ;5]L96YG=& H<FAS+FU?;&5N9W1H*0T*("  ("P ;5]B87-E*')H

M7V%S<V5R="AI<U]V86QI9" I*3L-"GT-" T*=&5M<&QA=&4\("  <W-?='EP

M;5]K(%0-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 00T*("  

M<VEC7W-T<FEN9U]V:65W*&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^(&-O
M;G-T("9R:',L('-S7W1Y<&5N86UE7W1Y<&5?:R!B87-I8U]S=')I;F=?=FEE

M<RYM7VQE;F=T:" M('!O<RD-"B  (" L(&U?8F%S92 F<FAS6W!O<UTI("\O
M(%5S92!T:&ES('-O('=E(&=E="!T:&4 9&5B=6<M=&EM92!I;G9A<FEA;G0 
M8VAE8VMI;F< ;VX =&AE('9A;&ED:71Y(&]F('!O<PT*("  ("P ;5]C<W1R



M("P ("!S<U]T>7!E;F%M95]P87)A;5]K(%0-"B  ("  ("  +"  ('-S7W1Y

M:6YG7W9I97<\0RP 5"P 03XZ.F)A<VEC7W-T<FEN9U]V:65W*"  (&)A<VEC
M7W-T<FEN9U]V:65W/$,L(%0L($$^(&-O;G-T("  ("  ("  ("  ("  ("  
M("  ("  ("  ("9R:',-"B  ("  ("  ("  ("  ("  ("  ("  ("  ("  
M("  ("  ("  ("  ("  ("  ("  (" L("  <W-?='EP96YA;65?='EP95]K
M(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIS:7IE7W1Y<&4 ("  <&]S

M("  ("  ("  +"  ('-S7W1Y<&5N86UE7W1Y<&5?:R!B87-I8U]S=')I;F=?

M9W1H*&-C:"D-"B  (" L(&U?8F%S92 F<FAS6W!O<UTI("\O(%5S92!T:&ES
M('-O('=E(&=E="!T:&4 9&5B=6<M=&EM92!I;G9A<FEA;G0 8VAE8VMI;F< 


M871E/"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 0PT*("  ("  (" L("  <W-?

M87)A;5]K($$-"B  ("  ("  / T*:6YL:6YE(&)A<VEC7W-T<FEN9U]V:65W
M/$,L(%0L($$^.CIB87-I8U]S=')I;F=?=FEE=RAS<U]T>7!E;F%M95]T>7!E
M7VL 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.F-H87)?='EP92!C;VYS
M=" J<RD-"B  (" Z(&U?;&5N9W1H*%0Z.FQE;F=T:"AS*2D-"B  (" L(&U?


M86UE7W!A<F%M7VL 0PT*("  ("  (" L("  <W-?='EP96YA;65?<&%R86U?

M("  / T*:6YL:6YE(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIB87-I
M8U]S=')I;F=?=FEE=R  ("!S<U]T>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R
M:6YG7W9I97<\0RP 5"P 03XZ.F-H87)?='EP92!C;VYS="  *G,-"B  ("  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  
M(" L("  <W-?='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W/$,L
M(%0L($$^.CIS:7IE7W1Y<&4 ("  ("  (&-C:"D-"B  (" Z(&U?;&5N9W1H


M9&5F:6YE9"A?7U-43%-/1E1?0T9?345-0D527U1%35!,051%7U)!3D=%7TU%
M5$A/1%]355!03U)4*0T*=&5M<&QA=&4\("  <W-?='EP96YA;65?<&%R86U?


M;F4 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.F)A<VEC7W-T<FEN9U]V

M+"!4+"!!/CHZ8VAA<E]T>7!E(&-O;G-T(" J9FER<W0-"B  ("  ("  ("  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  (" L("  
M<W-?='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^
M.CIC:&%R7W1Y<&4 8V]N<W0 ("IL87-T*0T*("  (#H ;5]L96YG=& H;&%S
M=" M(&9I<G-T*0T*("  ("P ;5]B87-E*&9I<G-T*0T*("  ("P ;5]C<W1R


M9B O*B!?7U-43%-/1E1?0T9?345-0D527U1%35!,051%7U)!3D=%7TU%5$A/


M("  ("P ("!S<U]T>7!E;F%M95]P87)A;5]K($$-"B  ("  ("  / T*:6YL
M:6YE(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CI^8F%S:6-?<W1R:6YG
M7W9I97<H*0T*>PT*("  ('-T;'-O9G1?87-S97)T*&ES7W9A;&ED*"DI.PT*


M93P ("!S<U]T>7!E;F%M95]P87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y
M<&5N86UE7W!A<F%M7VL 5 T*("  ("  (" L("  <W-?='EP96YA;65?<&%R

M:65W/$,L(%0L($$^.CIS=V%P*'-S7W1Y<&5N86UE7W1Y<&5?:R!B87-I8U]S


M*&U?;&5N9W1H+"!R:',N;5]L96YG=& I.PT*("  ('-T9#HZ<W=A<"AM7V)A
M<V4L(')H<RYM7V)A<V4I.PT*("  ('-T9#HZ<W=A<"AM7V-S='(L(')H<RYM



M>7!E;F%M95]P87)A;5]K($$-"B  ("  ("  / T*:6YL:6YE('9O:60 8F%S
M:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.F-L96%R*"D-"GL-"B  ("!S=&QS
M;V9T7V%S<V5R="AI<U]V86QI9" I*3L-" T*("  (&U?;&5N9W1H("  (#T 
M(" P.PT*("  (&U?8F%S92  ("  (#T




M("  ("P ("!S<U]T>7!E;F%M95]P87)A;5]K($$-"B  ("  ("  / T*:6YL

M+"!!/CHZ<VEZ95]T>7!E(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIS
M:7IE*"D 8V]N<W0-"GL-"B  ("!S=&QS;V9T7V%S<V5R="AI<U]V86QI9" I
M*3L-" T*("  (')E='5R;B!M7VQE;F=T:#L-"GT-" T*=&5M<&QA=&4\("  

M95]P87)A;5]K(%0-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 



M("  <F5T=7)N('-T871I8U]C87-T/'-I>F5?='EP93XH+3$I("\ <VEZ96]F

M;VYS=#L-
M("  ("  ("P ("!S<U]T>7!E;F%M95]P87)A;5]K(%0-"B  ("  ("  +"  

M='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIS
M:7IE7W1Y<&4 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.FQE;F=T:" I


M<&5N86UE7W!A<F%M7VL 0PT*("  ("  (" L("  <W-?='EP96YA;65?<&%R

M("  ("  / T*:6YL:6YE('-S7W1Y<&5N86UE7W1Y<&5?:R!B87-I8U]S=')I





M>7!E;F%M95]P87)A;5]K($$-"B  ("  ("  / T*:6YL:6YE('-S7V)O;VQ?



M871E/"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 0PT*("  ("  (" L("  <W-?

M87)A;5]K($$-"B  ("  ("  / T*:6YL:6YE('-S7V)O;VQ?="!B87-I8U]S

M(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIC;&%S<U]T>7!E(&-O;G-T


M)B8 *"AM7V)A<V4 /3T <FAS+FU?8F%S92D ?'P ," ]/2!C;VUP87)E*')H

M"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*("  ("  (" L

M<U]B;V]L7W0 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.F5Q=6%L*'-S

M=F%L=65?='EP92!C;VYS=" J<FAS+"!S<U]T>7!E;F%M95]T>7!E7VL 8F%S
M:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.G-I>F5?='EP92!C8VA2:',I(&-O

M("!R971U<FX *&U?;&5N9W1H(#T](&-C:%)H<RD )B8 *"AM7V)A<V4 /3T 
M<FAS*2!\?" P(#T](&-O;7!A<F5?*&U?8F%S92P ;5]L96YG=& L(')H<RP 



M;FQI;F4 <W-?<VEN=%]T(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIC
M;VUP87)E*"  ('-S7W1Y<&5N86UE7W1Y<&5?:R!B87-I8U]S=')I;F=?=FEE

M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("P 
M("!S<U]T>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 
M03XZ.G-I>F5?='EP92  ("  ("  ("!C8V -"B  ("  ("  ("  ("  ("  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  (" L("  <W-?='EP
M96YA;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIV86QU
M95]T>7!E(&-O;G-T("  *G)H<PT*("  ("  ("  ("  ("  ("  ("  ("  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("P ("!S<U]T>7!E;F%M95]T
M>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.G-I>F5?='EP92  


M96YG=& H*3L-" T*("  (&EF*"$H<&]S(#P


M8V  /"!L:'-?;&5N*0T*("  ('L-"B  ("  ("  ;&AS7VQE;B ](&-C:#L-



M(#T 8V-H4FAS.PT*("  ('T-" T*("  ('-T;'-O9G1?87-S97)T*&ES7W9A

M;&AS7VQE;BP <FAS+"!R:'-?;&5N*3L-"GT-" T*=&5M<&QA=&4\("  <W-?

M87)A;5]K(%0-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 00T*

M/$,L(%0L($$^.CIC;VUP87)E*"  ('-S7W1Y<&5N86UE7W1Y<&5?:R!B87-I

M<PT*("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  
M("  ("  ("  ("P ("!S<U]T>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R:6YG
M7W9I97<\0RP 5"P 03XZ.G-I>F5?='EP92  ("  ("  ("!C8V -"B  ("  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  
M(" L("  <W-?='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W/$,L
M(%0L($$^.CIV86QU95]T>7!E(&-O;G-T("  *G)H<RD 8V]N<W0-"GL-"B  
M("!S=&QS;V9T7V%S<V5R="AI<U]V86QI9" I*3L-" T*("  ('-I>F5?='EP




M("!L:'-?;&5N(#T 8V-H.PT*("  ('T-" T*("  ('-I>F5?='EP92  (')H
M<U]L96X /2  ("A.54Q,(#T](')H<RD /R P(#H =')A:71S7W1Y<&4Z.FQE



M95]P87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 

M(#X-"FEN;&EN92!S<U]S:6YT7W0 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 
M03XZ.F-O;7!A<F4H<W-?='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN9U]V


M7W1Y<&4 ("!L:'-?;&5N(#T ("!L96YG=& H*3L-"B  ("!S:7IE7W1Y<&4 
M("!R:'-?;&5N(#T
M.CIL96YG=& H<FAS*3L-" T*("  (')E='5R;B!C;VUP87)E7RAM7V)A<V4L

M7W1Y<&5N86UE7W!A<F%M7VL 0PT*("  ("  (" L("  <W-?='EP96YA;65?

M"B  ("  ("  / T*:6YL:6YE('-S7W-I;G1?="!B87-I8U]S=')I;F=?=FEE

M:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.G-I>F5?='EP92  ("  ("  ("!P
M;W,-"B  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  
M("  ("  ("  (" L("  <W-?='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN

M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  

M+"!4+"!!/CHZ8VQA<W-?='EP92!C;VYS="  ("9R:',-"B  ("  ("  ("  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  (" L("  
M<W-?='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^

M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  +"  ('-S7W1Y

M95]T>7!E("  ("  ("  (&-C:%)H<RD 8V]N<W0-"GL-"B  ("!S=&QS;V9T
M7V%S<V5R="AI<U]V86QI9" I*3L-" T*("  ('-I>F5?='EP92  (&QH<U]L




M(#T 8V-H.PT*("  ('T-" T*("  ('-I>F5?='EP92  (')H<U]L96X /2  
M(')H<RYL96YG=& H*3L-" T*("  (&EF*"$H<&]S4FAS(#P <FAS7VQE;BDI




M<V5R="AI<U]V86QI9" I*3L-" T*("  (')E='5R;B!C;VUP87)E7RAM7V)A
M<V4 *R!P;W,L(&QH<U]L96XL(')H<RYM7V)A<V4 *R!P;W-2:',L(')H<U]L

M"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*("  ("  (" L

M<U]S:6YT7W0 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.F-O;7!A<F4H
M("  <W-?='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L

M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  +"  ('-S7W1Y

M95]T>7!E("  ("  ("  (&-C: T*("  ("  ("  ("  ("  ("  ("  ("  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("P ("!S<U]T>7!E;F%M95]T
M>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.F-L87-S7W1Y<&4 
M8V]N<W0 (" F<FAS*2!C;VYS= T*>PT*("  ('-T;'-O9G1?87-S97)T*&ES


M("  ("  <&]S(#T

M(#P


M("!R971U<FX 8V]M<&%R95\H;5]B87-E("L <&]S+"!L:'-?;&5N+"!R:',N
M;5]B87-E+"!R:'-?;&5N*3L-"GT-" T*=&5M<&QA=&4\("  <W-?='EP96YA

M(%0-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 00T*("  ("  

M($$^.CIC;VUP87)E*'-S7W1Y<&5N86UE7W1Y<&5?:R!B87-I8U]S=')I;F=?





M87-E+"!L:'-?;&5N+"!R:',N;5]B87-E+"!R:'-?;&5N*3L-"GT-" T*+R\ 

M87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*

M"FEN;&EN92!S<U]T>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\

M/CHZ;W!E<F%T;W( 6UTH<W-?='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN



M7W1Y<&5N86UE7W!A<F%M7VL 0PT*("  ("  (" L("  <W-?='EP96YA;65?

M"B  ("  ("  / T*:6YL:6YE('-S7W1Y<&5N86UE7W1Y<&5?:R!B87-I8U]S

M<FEN9U]V:65W/$,L(%0L($$^.CIO<&5R871O<B!;72AS<U]T>7!E;F%M95]T
M>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.G-I>F5?='EP92!I
M;F1E>"D 8V]N<W0-"GL-"B  ("!S=&QS;V9T7V%S<V5R="AI<U]V86QI9" I

M93P ("!S<U]T>7!E;F%M95]P87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y
M<&5N86UE7W!A<F%M7VL 5 T*("  ("  (" L("  <W-?='EP96YA;65?<&%R

M8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.G9A;'5E7W1Y<&4 8V]N<W0 






M>PT*("  ("  ("  ("  +R\ 375S="!A;&QO8V%T92!T:&4 ;5]C<W1R(&UE

M("  ("  ("!C:&%R7W1Y<&4 ("  ("  *G, (#T ("!A=&]R+F%L;&]C871E

M;W!Y*',L(&U?8F%S92P ;5]L96YG=& I.PT*("  ("  ("  ("  <UMM7VQE




M;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*("  

M;&EN92!S<U]T>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\0RP 
M5"P 03XZ.G9A;'5E7W1Y<&4 8V]N<W0 *F)A<VEC7W-T<FEN9U]V:65W/$,L
M(%0L($$^.CID871A*"D 8V]N<W0-"GL-"B  ("!S=&QS;V9T7V%S<V5R="AI

M96UP='E?<W1R:6YG7R I(#H

M>7!E;F%M95]P87)A;5]K(%0-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A

M(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIR969E<F5N8V4 8F%S:6-?
M<W1R:6YG7W9I97<\0RP 5"P 03XZ.F9R;VYT*"D-"GL-"B  ("!S=&QS;V9T
M7V%S<V5R="AI<U]V86QI9" I*3L-" T*("  (')E='5R;B H*G1H:7,I6S!=

M("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*("  ("  (" L("  

M>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.G)E




M("P ("!S<U]T>7!E;F%M95]P87)A;5]K(%0-"B  ("  ("  +"  ('-S7W1Y

M;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIC;VYS=%]R
M969E<F5N8V4 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.F9R;VYT*"D 
M8V]N<W0-"GL-"B  ("!S=&QS;V9T7V%S<V5R="AI<U]V86QI9" I*3L-" T*

M>7!E;F%M95]P87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A

M("  ("  (#X-"FEN;&EN92!S<U]T>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R
M:6YG7W9I97<\0RP 5"P 03XZ.F-O;G-T7W)E9F5R96YC92!B87-I8U]S=')I



M87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*

M"FEN;&EN92!S<U]T>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\

M/CHZ8V]P>2  ("!S<U]T>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R:6YG7W9I

M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  (" L("  
M<W-?='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^
M.CIS:7IE7W1Y<&4 ("  ("!C8V -"B  ("  ("  ("  ("  ("  ("  ("  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  ("  
M("  ("  ("  ("  ("  ("  ("  ("  ("  ("P ("!S<U]T>7!E;F%M95]T
M>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.G-I>F5?='EP92  



M:68H;&5N(#P





M>7!E;F%M95]P87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A

M("  ("  (#X-"FEN;&EN92!S<U]T>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R
M:6YG7W9I97<\0RP 5"P 03XZ.F-O;G-T7VET97)A=&]R(&)A<VEC7W-T<FEN



M("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*("  ("  (" L("  <W-?

M;F%M95]T>7!E7VL 8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.F-O;G-T
M7VET97)A=&]R(&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^.CIE;F0H*2!C

M("  <F5T=7)N(&)E9VEN*"D *R!M7VQE;F=T:#L-
M;7!L871E/"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 0PT*("  ("  (" L("  

M95]P87)A;5]K($$-"B  ("  ("  / T*:6YL:6YE('-S7W1Y<&5N86UE7W1Y

M:6-?<W1R:6YG7W9I97<\0RP 5"P 03XZ.F)E9VEN*"D-"GL-"B  ("!S=&QS
M;V9T7V%S<V5R="AI<U]V86QI9" I*3L-" T*("  (')E='5R;B!M7V)A<V4[


M<U]T>7!E;F%M95]P87)A;5]K($$-"B  ("  ("  / T*:6YL:6YE('-S7W1Y




M(&1E9FEN960H7U]35$Q33T947T-&7T))1$E214-424].04Q?251%4D%43U)?
M4U504$]25"D-"G1E;7!L871E/"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 0PT*

M("!S<U]T>7!E;F%M95]P87)A;5]K($$-"B  ("  ("  / T*:6YL:6YE('-S


M+"!!/CHZ<F)E9VEN*"D 8V]N<W0-"GL-"B  ("!S=&QS;V9T7V%S<V5R="AI
M<U]V86QI9" I*3L-" T*("  (')E='5R;B!C;VYS=%]R979E<G-E7VET97)A
M=&]R*&5N9" I*3L-"GT-" T*=&5M<&QA=&4\("  <W-?='EP96YA;65?<&%R


M;FQI;F4 <W-?='EP96YA;65?='EP95]K(&)A<VEC7W-T<FEN9U]V:65W/$,L
M(%0L($$^.CIC;VYS=%]R979E<G-E7VET97)A=&]R(&)A<VEC7W-T<FEN9U]V
M:65W/$,L(%0L($$^.CIR96YD*"D 8V]N<W0-"GL-"B  ("!S=&QS;V9T7V%S
M<V5R="AI<U]V86QI9" I*3L-" T*("  (')E='5R;B!C;VYS=%]R979E<G-E


M95]P87)A;5]K(%0-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 

M7W-T<FEN9U]V:65W/$,L(%0L($$^.CIR979E<G-E7VET97)A=&]R(&)A<VEC
M7W-T<FEN9U]V:65W/$,L(%0L($$^.CIR8F5G:6XH*0T*>PT*("  ('-T;'-O


M95]P87)A;5]K($,-"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 

M(#X-"FEN;&EN92!S<U]T>7!E;F%M95]T>7!E7VL 8F%S:6-?<W1R:6YG7W9I
M97<\0RP 5"P 03XZ.G)E=F5R<V5?:71E<F%T;W( 8F%S:6-?<W1R:6YG7W9I
M97<\0RP 5"P 03XZ.G)E;F0H*0T*>PT*("  ('-T;'-O9G1?87-S97)T*&ES



M+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O
M+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\-"B J(%-T<FEN9R!A

M*B\-" T*+R\O(%QB<FEE9B!2971U<FYS('1H92!C;W)R97-P;VYD:6YG($,M
M<W1R:6YG('!O:6YT97( ;V8 7&, <RP ;W( 82!N=6QL('!O:6YT97(-"G1E
M;7!L871E/"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 0PT*("  ("  (" L("  

M95]P87)A;5]K($$-"B  ("  ("  / T*:6YL:6YE($, 8V]N<W0 *F-?<W1R
M7W!T<E]N=6QL*&)A<VEC7W-T<FEN9U]V:65W/$,L(%0L($$^(&-O;G-T("9S


M='5R;G, =&AE(&-O<G)E<W!O;F1I;F< 0RUS=')I;F< <&]I;G1E<B!O9B!<

M("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 5 T*("  ("  (" L("  <W-?

M("IC7W-T<E]P='(H8F%S:6-?<W1R:6YG7W9I97<\0RP 5"P 03X 8V]N<W0 

M9B!2971U<FYS('1H92!C;W)R97-P;VYD:6YG($,M<W1R:6YG('!O:6YT97( 

M("  ("  ("P ("!S<U]T>7!E;F%M95]P87)A;5]K($$-"B  ("  ("  / T*
M:6YL:6YE('-S7V-H87)?85]T(&-O;G-T("IC7W-T<E]P=')?82AB87-I8U]S

M("  <F5T=7)N(',N8U]S='(H*3L-"GT-" T*+R\O(%QB<FEE9B!2971U<FYS
M('1H92!C;W)R97-P;VYD:6YG($,M<W1R:6YG('!O:6YT97( ;V8 7&, <PT*

M("!S<U]T>7!E;F%M95]P87)A;5]K($$-"B  ("  ("  / T*:6YL:6YE('-S
M7V-H87)?=U]T(&-O;G-T("IC7W-T<E]P=')?=RAB87-I8U]S=')I;F=?=FEE


M7&)R:65F(%)E='5R;G, =&AE(&QE;F=T:" H:6X 8VAA<F%C=&5R<RD ;V8 
M7&, <RP /&(^/&D^;F]T/"]I/CPO8CX :6YC;'5D:6YG('1H92!N=6QL+71E
M<FUI;F%T:6YG(&-H87)A8W1E< T*=&5M<&QA=&4\("  <W-?='EP96YA;65?

M"B  ("  ("  +"  ('-S7W1Y<&5N86UE7W!A<F%M7VL 00T*("  ("  (" ^


M*3L-"GT-" T*+RH 8U]S=')?<'1R7W-I>F4 *B\-" T*+R\O(%QB<FEE9B!2
M971U<FYS('1H92!S:7IE("AI;B!B>71E<RD ;V8 =&AE(&-O;G1E;G1S(&]F
M(%QC(',L(#QB/CQI/FYO=#PO:3X\+V(^(&EN8VQU9&EN9R!T:&4 ;G5L;"UT
M97)M:6YA=&EN9R!C:&%R86-T97(-"G1E;7!L871E/"  ('-S7W1Y<&5N86UE
M7W!A<F%M7VL 0PT*("  ("  (" L("  <W-?='EP96YA;65?<&%R86U?:R!4

M/ T*:6YL:6YE('-S7W-I>F5?="!C7W-T<E]S:7IE*&)A<VEC7W-T<FEN9U]V
M:65W/$,L(%0L($$^(&-O;G-T("9S*0T*>PT*("  (')E='5R;B!C7W-T<E]L




M+R\ 0'T +R\ 96YD(&]F(&=R;W5P('-T;'-O9G1?<W1R:6YG7VQI8G)A<GD-
M" T*+RH +R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O
M+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\ *B\-" T*(VEF
M;F1E9B!?4U1,4T]&5%].3U].04U%4U!!0T4-"GT +R\ ;F%M97-P86-E('-T
M;'-O9G0-"B-E;F1I9B O*B!?4U1,4T]&5%].3U].04U%4U!!0T4 *B\-" T*
M+RH +R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O
M+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\ *B\-" T*(V5N9&EF

M"B\J("\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O+R\O

`
end
Mar 31 2005