[32698] in Perl-Users-Digest
Perl-Users Digest, Issue: 3962 Volume: 11
daemon@ATHENA.MIT.EDU (Perl-Users Digest)
Tue Jun 11 14:09:32 2013
Date: Tue, 11 Jun 2013 11:09:05 -0700 (PDT)
From: Perl-Users Digest <Perl-Users-Request@ruby.OCE.ORST.EDU>
To: Perl-Users@ruby.OCE.ORST.EDU (Perl-Users Digest)
Perl-Users Digest Tue, 11 Jun 2013 Volume: 11 Number: 3962
Today's topics:
advice needed for color selection <nospam@lisse.NA>
dancer or mojo whats best perl web framework now? <visphatesjava@gmail.com>
Re: Is there a better way than this? <daves@orpheusmail.co.uk>
Re: Is there a better way than this? (Tim McDaniel)
Re: Is there a better way than this? <ben@morrow.me.uk>
Re: Is there a better way than this? (Tim McDaniel)
Re: Is there a better way than this? (Tim McDaniel)
Re: Is there a better way than this? <ben@morrow.me.uk>
Re: Is there a better way than this? (Tim McDaniel)
Re: Is there a better way than this? <ben@morrow.me.uk>
Is this comparison valid? gamo@telecable.es
Re: Is this comparison valid? <jurgenex@hotmail.com>
Re: Is this comparison valid? gamo@telecable.es
Re: Is this comparison valid? <jurgenex@hotmail.com>
Re: Is this comparison valid? <*@eli.users.panix.com>
Re: Is this comparison valid? gamo@telecable.es
Digest Administrivia (Last modified: 6 Apr 01) (Perl-Users-Digest Admin)
----------------------------------------------------------------------
Date: Mon, 10 Jun 2013 12:49:38 +0100
From: Dr Eberhard Lisse <nospam@lisse.NA>
Subject: advice needed for color selection
Message-Id: <b1lsqkFh63oU1@mid.individual.net>
Hi,
I have a variable number of entities (from an SQL script) each of which
I want to assign a color to so I can print them with GraphViz.
How do I select the most visible colors?
Ie if I have 10, 30, 57, 98, 259 entities, how do I select appropriate
colours (dynamically, so to speak) so that they (and of course arrows
originating from them but that is easy to do in GraphViz) become most
visible on (white) paper?
Pointers are as welcome as finished product :-)-O
el
------------------------------
Date: Sat, 8 Jun 2013 20:54:28 -0700 (PDT)
From: johannes falcone <visphatesjava@gmail.com>
Subject: dancer or mojo whats best perl web framework now?
Message-Id: <494f5c01-586a-4b25-be79-ac8f6adf8b71@googlegroups.com>
wondering?
------------------------------
Date: Sat, 08 Jun 2013 13:11:30 +0100
From: Dave Stratford <daves@orpheusmail.co.uk>
Subject: Re: Is there a better way than this?
Message-Id: <535891b281daves@orpheusmail.co.uk>
In article <87wqq9iwmi.fsf@sapphire.mobileactivedefense.com>,
Rainer Weikusat <rweikusat@mssgmbh.com> wrote:
> Helmut Richter <hhr-m@web.de> writes:
> > On Tue, 4 Jun 2013, Dave Stratford wrote:
> >
> >> My requirements are to extract the initial letter(s) from the
> >> outcode. So if a user entered HP13, I want to extract just the HP,
> >> equally if they emtered WC1A, I want just the WC.
> >>
> >> My current code, which works perfectly fine, looks like this:
> >>
> >> my $oc = substr($outcode,0,2);
> >> my $ocr = substr($oc,1,1);
> >>
> >> $oc = substr($outcode,0,1) if ($ocr =~ /\d/);
> >
> > What about
> >
> > $outcode =~ /^([A-Z]+)\d/;
> > $oc = $1;
> If the regex didn't match, $oc will now contain the value captured by
> the last successful regex match before this line. This may not be a
> problem in this case but in general, it is prudent to use the $n only
> when the corresponding match was successful. Assuming that $oc is
> guaranteed to be intially uninitialized, I would use something like
> $outcode =~ /^([A-Z]{1,2})\d/ and $oc = $1; [*]
> $oc will now have the correct value if outcode really started with one
> or two letters followed by a digit. Depending on where the input came
> from, [0-9] instead of \d might be a better choice as UK postcodes
> certainly use arabic numerals but \d might match anything the Unicode
> consortium considers a digit now or in future.
> [*]
> The obivious other way to write this is
> ($oc) = $outcode =~ /^([A-Z]{1,2})\d/;
Thanks everyone, most appreciated.
I've gone with
$oc =~ /^([A-Z)+)/a;
as in fact I've already previously validated the entire input string viz:
sub valid_outcode
{
my $str = shift;
my $regex =
qr{^([BGLMNS][1-9][0-9]?|[A-PR-UWYZ][A-HK-Y][1-9]?[0-9]|([EW]C?|NW?|S[EW])[1-9][0-9A-HJKMNPR-Y])$}i;
return ($str =~ $regex);
}
I realise that I could probably have used $_ rather than "my $str =
shift;", but I just prefer to do it this way, that way I remember what I
dealing with, particularly on larger subs.
Actually Rainer, why did you do ($oc)? I understand that the () in this
context returns a list?
Many thanks,
Dave
--
Dave Stratford - ZFCB
http://daves.orpheusweb.co.uk/
------------------------------
Date: Sat, 8 Jun 2013 15:17:09 +0000 (UTC)
From: tmcd@panix.com (Tim McDaniel)
Subject: Re: Is there a better way than this?
Message-Id: <kovhtl$2i7$1@reader1.panix.com>
In article <535891b281daves@orpheusmail.co.uk>,
Dave Stratford <daves@orpheusmail.co.uk> wrote:
>In article <87wqq9iwmi.fsf@sapphire.mobileactivedefense.com>,
> Rainer Weikusat <rweikusat@mssgmbh.com> wrote:
>> Helmut Richter <hhr-m@web.de> writes:
>> > On Tue, 4 Jun 2013, Dave Stratford wrote:
>> >
>> >> My requirements are to extract the initial letter(s) from the
>> >> outcode. So if a user entered HP13, I want to extract just the HP,
>> >> equally if they emtered WC1A, I want just the WC.
>> >>
>> >> My current code, which works perfectly fine, looks like this:
>> >>
>> >> my $oc = substr($outcode,0,2);
>> >> my $ocr = substr($oc,1,1);
>> >>
>> >> $oc = substr($outcode,0,1) if ($ocr =~ /\d/);
>> >
>> > What about
>> >
>> > $outcode =~ /^([A-Z]+)\d/;
>> > $oc = $1;
>>
...
>> The obivious other way to write this is
>
>> ($oc) = $outcode =~ /^([A-Z]{1,2})\d/;
>
...
>I've gone with
>$oc =~ /^([A-Z)+)/a;
Did you typo "$oc = " as "$oc =~ "? Because the =~ form would change
the meaning from all the suggestions: it would pattern-match against
$oc and the matching part would go into $1, which has already been
suggested against.
Also: I am not familiar with /a and friends, but I think it's useless
here. Looking at the next RE, did you mean /i instead?
>sub valid_outcode
>{
> my $str = shift;
> my $regex =
>qr{^([BGLMNS][1-9][0-9]?|[A-PR-UWYZ][A-HK-Y][1-9]?[0-9]|([EW]C?|NW?|S[EW])[1-9][0-9A-HJKMNPR-Y])$}i;
>
> return ($str =~ $regex);
>}
That returns the value of the match differently in list context from
scalar context, so in an array context the caller would get random
bits of the pattern match. I would code it as returning a boolean,
which could be written
return ($str =~ $regex ? 1 : 0);
(at a quick look, I can't figure out the precedence rules in perlop to
know whether the parens could be omitted) or more succinctly
return scalar ($str =~ $regex);
return !!($str =~ $regex);
>I realise that I could probably have used $_ rather than "my $str =
>shift;", but I just prefer to do it this way, that way I remember
>what I dealing with, particularly on larger subs.
I like that too.
>> ($oc) = $outcode =~ /^([A-Z]{1,2})\d/;
>
>Actually Rainer, why did you do ($oc)? I understand that the () in
>this context returns a list?
More precisely, it causes the left-hand side to be a list context, so
the right-hand side is evaluated in a list context. Out of
"man perlop":
Binary "=~" binds a scalar expression to a pattern match.
... When used in scalar context, the return value generally
indicates the success of the operation. ...
m/PATTERN/msixpodualgc
/PATTERN/msixpodualgc
...
Matching in list context
If the "/g" option is not used, "m//" in list context returns a
list consisting of the subexpressions matched by the parentheses
in the pattern, i.e., ($1, $2, $3...). (Note that here $1
etc. are also set, and that this differs from Perl 4's behavior.)
When there are no parentheses in the pattern, the return value is
the list "(1)" for success. With or without parentheses, an empty
list is returned upon failure.
So
$oc = $outcode =~ /^([A-Z]{1,2})\d/;
would set $oc to merely true or false.
($oc) = $outcode =~ /^([A-Z]{1,2})\d/;
assigns the matched letters to it (or undef if it doesn't match).
--
Tim McDaniel, tmcd@panix.com
------------------------------
Date: Sat, 8 Jun 2013 18:34:13 +0100
From: Ben Morrow <ben@morrow.me.uk>
Subject: Re: Is there a better way than this?
Message-Id: <lh6c8a-67f2.ln1@anubis.morrow.me.uk>
Quoth tmcd@panix.com:
> In article <535891b281daves@orpheusmail.co.uk>,
> Dave Stratford <daves@orpheusmail.co.uk> wrote:
> >
> >I've gone with
> >$oc =~ /^([A-Z)+)/a;
>
> Did you typo "$oc = " as "$oc =~ "? Because the =~ form would change
> the meaning from all the suggestions: it would pattern-match against
> $oc and the matching part would go into $1, which has already been
> suggested against.
>
> Also: I am not familiar with /a and friends, but I think it's useless
> here.
That's correct. A single /a affects only \s\w\d. /aai has the additional
effect of preventing a non-ASCII character from case-insensitively
matching an ASCII character; this is only possible in a handful of
cases, such as
"ß" =~ /SS/i
which matches because the uppercase of "ß" is "SS". /aai prevents
matches like that, meaning that if your pattern is all ASCII then what
you match will be as well.
> return ($str =~ $regex ? 1 : 0);
>
> (at a quick look, I can't figure out the precedence rules in perlop to
> know whether the parens could be omitted)
~% perl -MO=Deparse,-p -e'return $s =~ $r ? 1 : 0'
(return (($str =~ /$rx/) ? 1 : 0));
-e syntax OK
So, no. 'return' is a list operator, and 'list operators (rightward)' is
lower precedence (binds less tightly) than everything except the named
logical ops.
> or more succinctly
>
> return scalar ($str =~ $regex);
That doesn't need the brackets either, for the same reason.
> >> ($oc) = $outcode =~ /^([A-Z]{1,2})\d/;
> >
> >Actually Rainer, why did you do ($oc)? I understand that the () in
> >this context returns a list?
>
> More precisely, it causes the left-hand side to be a list context, so
> the right-hand side is evaluated in a list context.
It's perhaps worth drawing a little more attention to this, since it's a
special case in the Perl parser and not a normal use of brackets for
precedence. Putting a single scalar term on the LHS of an = in a set of
unnecessary brackets explicitly turns the assignment into a list
assignment.
$oc = # scalar assignment
($oc) = # list assignment
Ben
------------------------------
Date: Sun, 9 Jun 2013 03:19:42 +0000 (UTC)
From: tmcd@panix.com (Tim McDaniel)
Subject: Re: Is there a better way than this?
Message-Id: <kp0s8d$9v4$1@reader1.panix.com>
In article <lh6c8a-67f2.ln1@anubis.morrow.me.uk>,
Ben Morrow <ben@morrow.me.uk> wrote:
>
>Quoth tmcd@panix.com:
>> return ($str =~ $regex ? 1 : 0);
>>
>> (at a quick look, I can't figure out the precedence rules in perlop
>> to know whether the parens could be omitted)
>
> ~% perl -MO=Deparse,-p -e'return $s =~ $r ? 1 : 0'
> (return (($str =~ /$rx/) ? 1 : 0));
> -e syntax OK
>
>So, no.
Um, so, yes, the parens can be omitted.
>'return' is a list operator
For future reference, where can I find that sort of thing documented?
>> or more succinctly
>>
>> return scalar ($str =~ $regex);
>
>That doesn't need the brackets either, for the same reason.
?: is not necessarily handled the same as scalar, so a priori to my
sort of non-cognoscenti it's not necessarily the same situation. I
think scalar is a named scalar operator, to go by the example in
perlfunc scalar:
# perl -MO=Deparse,-p -e'@counts = ( scalar @a, scalar @b, scalar @c);'
(@counts = (scalar(@a), scalar(@b), scalar(@c)));
-e syntax OK
But perlop says that =~ binds more closely than named unary
operators, so it's all OK anyway:
$ perl -MO=Deparse,-p -e'return scalar $str =~ $regex'
return(scalar(($str =~ /$regex/)));
-e syntax OK
--
Tim McDaniel, tmcd@panix.com
------------------------------
Date: Sun, 9 Jun 2013 03:29:24 +0000 (UTC)
From: tmcd@panix.com (Tim McDaniel)
Subject: Re: Is there a better way than this?
Message-Id: <kp0sqk$9v4$2@reader1.panix.com>
In article <lh6c8a-67f2.ln1@anubis.morrow.me.uk>,
Ben Morrow <ben@morrow.me.uk> wrote:
>It's perhaps worth drawing a little more attention to this, since
>it's a special case in the Perl parser and not a normal use of
>brackets for precedence. Putting a single scalar term on the LHS of
>an = in a set of unnecessary brackets explicitly turns the assignment
>into a list assignment.
>
> $oc = # scalar assignment
> ($oc) = # list assignment
Took me years to learn that.
To amplify on that point:
For example, suppose you (not you == Ben, you == one) do a common
idiom for handling args:
my ($file, $pattern, $count) = @ARGV;
Suppose you need only one argument. If you do
my $base = @ARGV;
$base will get the number of elements of arguments, not the first one.
You need
my ($base) = @ARGV;
with what you might think are redundant parens there, but (as Ben
mentioned) they're not, they're providing list context. It's a list
assignment and the left-hand side gets "my"ed, with the same effect as
my $base;
($base) = @ARGV;
As "man perlsub" puts it,
The "my" is simply a modifier on something you might assign to.
So when you do assign to variables in its argument list, "my"
doesn't change whether those variables are viewed as a scalar or
an array.
--
Tim McDaniel, tmcd@panix.com
------------------------------
Date: Mon, 10 Jun 2013 15:53:14 +0100
From: Ben Morrow <ben@morrow.me.uk>
Subject: Re: Is there a better way than this?
Message-Id: <qr5h8a-v4h.ln1@anubis.morrow.me.uk>
Quoth tmcd@panix.com:
> In article <lh6c8a-67f2.ln1@anubis.morrow.me.uk>,
> Ben Morrow <ben@morrow.me.uk> wrote:
> >
> >Quoth tmcd@panix.com:
> >> return ($str =~ $regex ? 1 : 0);
> >>
> >> (at a quick look, I can't figure out the precedence rules in perlop
> >> to know whether the parens could be omitted)
> >
> > ~% perl -MO=Deparse,-p -e'return $s =~ $r ? 1 : 0'
> > (return (($str =~ /$rx/) ? 1 : 0));
> > -e syntax OK
> >
> >So, no.
>
> Um, so, yes, the parens can be omitted.
EPOORCOMPREHENSION. I saw 'could be omitted' and read 'are necessary'...
> >'return' is a list operator
>
> For future reference, where can I find that sort of thing documented?
Subs that aren't prototyped ($) and builtins which take a LIST argument
in perlfunc are list operators, unless the first token after the
function name is a ( in which case the 'looks like a function' rule
comes into play and the argument list extends exactly to the matching ).
I'm not entirely sure about subs with prototypes like ($@) or the first
argument of builtins like 'join' which have equivalent rules, but I
suspect as far as precedence goes they are still 'list operators'.
> >> or more succinctly
> >>
> >> return scalar ($str =~ $regex);
> >
> >That doesn't need the brackets either, for the same reason.
>
> ?: is not necessarily handled the same as scalar, so a priori to my
> sort of non-cognoscenti it's not necessarily the same situation. I
> think scalar is a named scalar operator, to go by the example in
> perlfunc scalar:
>
> # perl -MO=Deparse,-p -e'@counts = ( scalar @a, scalar @b, scalar @c);'
> (@counts = (scalar(@a), scalar(@b), scalar(@c)));
> -e syntax OK
>
> But perlop says that =~ binds more closely than named unary
> operators, so it's all OK anyway:
Yes, you're right.
Ben
------------------------------
Date: Mon, 10 Jun 2013 18:46:37 +0000 (UTC)
From: tmcd@panix.com (Tim McDaniel)
Subject: Re: Is there a better way than this?
Message-Id: <kp56ud$8ne$1@reader1.panix.com>
In article <qr5h8a-v4h.ln1@anubis.morrow.me.uk>,
Ben Morrow <ben@morrow.me.uk> wrote:
>
>Quoth tmcd@panix.com:
>> In article <lh6c8a-67f2.ln1@anubis.morrow.me.uk>,
>> Ben Morrow <ben@morrow.me.uk> wrote:
>> >'return' is a list operator
>>
>> For future reference, where can I find that sort of thing
>> documented?
I meant for builtins.
>... builtins which take a LIST argument in perlfunc are list
>operators
return EXPR
return
Returns from a subroutine, eval, or do FILE with the value given
in EXPR. Evaluation of EXPR may be in list, scalar, or void
context, depending on how the return value will be used, ...
doesn't say LIST, but you say it's a list operator, and that makes
ense because it can return lists.
--
Tim McDaniel, tmcd@panix.com
------------------------------
Date: Tue, 11 Jun 2013 00:15:19 +0100
From: Ben Morrow <ben@morrow.me.uk>
Subject: Re: Is there a better way than this?
Message-Id: <793i8a-gdm.ln1@anubis.morrow.me.uk>
Quoth tmcd@panix.com:
> In article <qr5h8a-v4h.ln1@anubis.morrow.me.uk>,
> Ben Morrow <ben@morrow.me.uk> wrote:
>
> >... builtins which take a LIST argument in perlfunc are list
> >operators
>
> return EXPR
>
> return
>
> Returns from a subroutine, eval, or do FILE with the value given
> in EXPR. Evaluation of EXPR may be in list, scalar, or void
> context, depending on how the return value will be used, ...
>
> doesn't say LIST, but you say it's a list operator, and that makes
> ense because it can return lists.
That's interesting, actually. For starters, the perlfunc entry is
definitely wrong: regardless of the eventual context return gives to its
arguments, it always parses as a list operator. It has to, because only
one optree is built regardless of the eventual context the sub will be
called in. However, it isn't quite the same as an ordinary listop: the
'looks like a function' rule doesn't apply, so
return (2 + 3) * 4;
returns 20, whereas a print or something would print 5 (and have its
return value multiplied by 4).
So, the simple answer to your question is 'no, it's not documented
anywhere'. AFAICT any (function-like) builtin which takes or can take
more than one argument is a listop, modulo 'looks like a function'.
Ben
------------------------------
Date: Sun, 9 Jun 2013 13:09:05 +0000 (UTC)
From: gamo@telecable.es
Subject: Is this comparison valid?
Message-Id: <kp1uph$sfo$1@speranza.aioe.org>
I have installed 5.18, and think that if hashes are randomized, maybe
a simple hash could substitute the shuffle operations, but I'm not sure
if the comparison is valid.
#!/usr/local/bin/perl -w
use List::Util qw(shuffle);
use Benchmark qw(:all);
for (1..100_000){
$list[$_] = $_;
$hash{$_} = $_;
}
cmpthese(-3, {
'shuffle' => sub { @aleat=shuffle(@list); },
'newhash' => sub { @aleat=values(%hash); },
});
timethese(-3, {
'shuffle' => sub { @aleat=shuffle(@list); },
'newhash' => sub { @aleat=values(%hash); },
});
__END__
------------------------------
Date: Sun, 09 Jun 2013 06:55:22 -0700
From: Jürgen Exner <jurgenex@hotmail.com>
Subject: Re: Is this comparison valid?
Message-Id: <i329r85ou78s7difqf0bcr4vnojpngua0b@4ax.com>
gamo@telecable.es wrote:
>I have installed 5.18, and think that if hashes are randomized,
Where did you read that hashes are randomized? AFAIK the sequence is
deterministic although of no practical value (and therefore may appear
to be randomized to the casual observer).
jue
------------------------------
Date: Sun, 9 Jun 2013 14:17:08 +0000 (UTC)
From: gamo@telecable.es
Subject: Re: Is this comparison valid?
Message-Id: <kp22p3$87r$1@speranza.aioe.org>
Where did you read that hashes are randomized? AFAIK the sequence is
deterministic although of no practical value (and therefore may appear
to be randomized to the casual observer).
jue
-------------------
in perldelta
it says:
Hash randomization
The seed used by Perl's hash function is now random. This means that
the order which keys/values will be returned from functions like
"keys()", "values()", and "each()" will differ from run to run.
------------------------------
Date: Sun, 09 Jun 2013 07:42:46 -0700
From: Jürgen Exner <jurgenex@hotmail.com>
Subject: Re: Is this comparison valid?
Message-Id: <3259r8hvg7psk392bhutcf94cmtf2iilfv@4ax.com>
gamo@telecable.es wrote:
>Where did you read that hashes are randomized? AFAIK the sequence is
>deterministic although of no practical value (and therefore may appear
>to be randomized to the casual observer).
>
>jue
>-------------------
>
>in perldelta
>
>it says:
>
> Hash randomization
>
> The seed used by Perl's hash function is now random. This means that
> the order which keys/values will be returned from functions like
> "keys()", "values()", and "each()" will differ from run to run.
Interesting.
Thanks
jue
------------------------------
Date: Mon, 10 Jun 2013 04:19:38 +0000 (UTC)
From: Eli the Bearded <*@eli.users.panix.com>
Subject: Re: Is this comparison valid?
Message-Id: <eli$1306100004@qz.little-neck.ny.us>
In comp.lang.perl.misc, <gamo@telecable.es> wrote:
[quoting but not properly attributing "jue"]
>> Where did you read that hashes are randomized? AFAIK the sequence is
>> deterministic although of no practical value (and therefore may appear
>> to be randomized to the casual observer).
> in perldelta it says:
> Hash randomization
> The seed used by Perl's hash function is now random. This means that
> the order which keys/values will be returned from functions like
> "keys()", "values()", and "each()" will differ from run to run.
That's a different sort of "random". Hashes suffer from a slowdown
/ attack that allows carefully chosen key strings to be different
but collide into the same internal hash. By using a random seed,
an attacker can not know what keys to choose to trigger this issue.
This sort of attack is something that can be an issue in any
framework that takes user input and puts it in a hash, eg, CGI
parameters.
The order of the strings is non-deterministic BETWEEN RUNS, but not
any other way. After a shuffle, the order is randomized. That can
be done as many times as you want / need in a single run of the
program. And two sets of keys with some overlap will be reliably
randomly ordered after a shuffle, but not after hashing.
In some limited cases, hashing may be "random" enough, but do remember
that is is based on a formula applied to the key string, whereas a
shuffle is a rearrangement that ignores the data altogether.
Elijah
------
understand your data structures
------------------------------
Date: Mon, 10 Jun 2013 06:39:58 +0000 (UTC)
From: gamo@telecable.es
Subject: Re: Is this comparison valid?
Message-Id: <kp3sbu$odn$1@speranza.aioe.org>
The order of the strings is non-deterministic BETWEEN RUNS, but not
any other way. After a shuffle, the order is randomized. That can
be done as many times as you want / need in a single run of the
program. And two sets of keys with some overlap will be reliably
randomly ordered after a shuffle, but not after hashing.
In some limited cases, hashing may be "random" enough, but do remember
that is is based on a formula applied to the key string, whereas a
shuffle is a rearrangement that ignores the data altogether.
Elijah
--------------------
Thank you for the explanation.
------------------------------
Date: 6 Apr 2001 21:33:47 GMT (Last modified)
From: Perl-Users-Request@ruby.oce.orst.edu (Perl-Users-Digest Admin)
Subject: Digest Administrivia (Last modified: 6 Apr 01)
Message-Id: <null>
Administrivia:
To submit articles to comp.lang.perl.announce, send your article to
clpa@perl.com.
Back issues are available via anonymous ftp from
ftp://cil-www.oce.orst.edu/pub/perl/old-digests.
#For other requests pertaining to the digest, send mail to
#perl-users-request@ruby.oce.orst.edu. Do not waste your time or mine
#sending perl questions to the -request address, I don't have time to
#answer them even if I did know the answer.
------------------------------
End of Perl-Users Digest V11 Issue 3962
***************************************
