view release on metacpan or  search on metacpan

Bulkmail.pm  view on Meta::CPAN

Also note that these speeds are only measuring the time it takes to get from Mail::Bulkmail to your SMTP relay. There are no
measurements reflecting how long it may take your SMTP relay to send the data on to the recipients on your list.

=item Am I going to see speeds that fast?

Maybe, maybe not.  It depends on how busy your SMTP server is.  If you have a relatively unused SMTP server with a fair amount
of horsepower and a fast connection, you can easily get these speeds or beyond.  If you have a relatively busy and/or low powered
SMTP server or slow connections, you're not going to reach speeds that fast.

=item How much faster will Mail::Bulkmail be than my current system?

This is a very tough question to answer, since it depends highly upon what your current system is.  For the sake of argument,
let's assume that for your current system, you open an SMTP connection to your server, send a message, and close the connection.
And then repeat.  Open, send, close, etc.

Mail::Bulkmail will I<always> be faster than this approach since it opens one SMTP connection and sends every single message across
on that one connection.  How much faster depends on how busy your server is as well as the size of your list. The connection will
only be closed if you have an error or if you reach the max number of messages to send in a given server connection.

Lets assume (for simplicity's sake) that you have a list of 100,000 people.  We'll also assume that you have a pretty busy
SMTP server and it takes (on average) 25 seconds for the server to respond to a connection request.  We're making 100,000
connection requests (with your old system).  That means 100,000 x 25 seconds = almost 29 days waiting just to make connections
to the server!  Mail::Bulkmail makes one connection, takes 25 seconds for it, and ends up being 100,000x faster!

But, now lets assume that you have a very unbusy SMTP server and it responds to connection requests in .003 seconds.  We're making
100,000 connection requests.  That means 100,000 x .0003 seconds = about 5 minutes waiting to make connections to the server.
Mail::Bulkmail makes on connection, takes .0003 seconds for it, and ends up only being 1666x faster.  But, even though being
1,666 times faster sounds impressive, the world won't stop spinning on its axis if you use your old system and take up an extra
5 minutes.

 view release on metacpan or  search on metacpan

t/corpus/comcast-via-sendmail.unknown.msg  view on Meta::CPAN

<recipient@example.net>
    (reason: 551 not our customer)

   ----- Transcript of session follows -----
... while talking to gateway-a.comcast.net.:
<<< 450 busy - please try later
... while talking to gateway-s.comcast.net.:
>>> DATA
<<< 551 not our customer
550 5.1.1 <recipient@example.net>... User unknown
<<< 503 need RCPT command [data]

 view release on metacpan or  search on metacpan

lib/Mail/Exchange/PidLidDefs.pm  view on Meta::CPAN

0x80c5 => { type => 0x0102, name => "PidLidFax2OriginalEntryId", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies a one-off EntryID corresponding to this fax address.
0x80d2 => { type => 0x001f, name => "PidLidFax3AddressType", guid => "00062004-0000-0000-C000-000000000046" }, # Contains the string value "FAX".
0x80d3 => { type => 0x001f, name => "PidLidFax3EmailAddress", guid => "00062004-0000-0000-C000-000000000046" }, # Contains a user-readable display name, followed by the "@" character, followed by a fax number.
0x80d4 => { type => 0x001f, name => "PidLidFax3OriginalDisplayName", guid => "00062004-0000-0000-C000-000000000046" }, # 
0x80d5 => { type => 0x0102, name => "PidLidFax3OriginalEntryId", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies a one-off EntryID that corresponds to this fax address.
0x80d8 => { type => 0x001f, name => "PidLidFreeBusyLocation", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies a URL path from which a client can retrieve free/busy status information for the contact.
0x80da => { type => 0x001f, name => "PidLidHomeAddressCountryCode", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies the country code portion of the contact's home address.
0x80db => { type => 0x001f, name => "PidLidWorkAddressCountryCode", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies the country code portion of the contact's work address.
0x80dc => { type => 0x001f, name => "PidLidOtherAddressCountryCode", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies the country code portion of the contact's other address.
0x80dd => { type => 0x001f, name => "PidLidAddressCountryCode", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies the country code portion of the contact's mailing address.
0x80de => { type => 0x0040, name => "PidLidBirthdayLocal", guid => "00062004-0000-0000-C000-000000000046" }, # Specifies the birthday of a contact.

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

Fixed some bugs in _send_line (the "O" side of the I/O engine) that were
reported by Danny Smith.

Fixed a bug in the migrate method in the optimization code (which 
gets called when socket writes are delayed due to a slow or busy target 
host, aka EAGAIN errors). Thanks to Pedro Carvalho for identifying 
this bug and its cause.

Fixed a bug in migrate that caused migration of unread messages to fail. 
This was due to the way Mail::IMAPClient's migrate method would try to send 

 view release on metacpan or  search on metacpan

qmailrem/CHANGES  view on Meta::CPAN

	 writes a pipeful to qmail-lspawn or qmail-rspawn before they
	 can react (because of high concurrency, high load, or long
	 addresses), it will receive an incorrect -1/EAGAIN, and will
	 conclude that spawn died. sysadmin will have to restart qmail,
	 and messages will be duplicated. fix: in qmail-send.c,
	 busy-loop if write() to spawn returns any error other than
	 EPIPE.
19960501 bug: qmail-alias treated NAMETOOLONG and NOTDIR as temporary
         errors. impact: qmail-alias never looked for -default; even if
	 mail was destined to bounce, it would have to time out first.
	 fix: qmail-alias now uses error_temp().

 view release on metacpan or  search on metacpan

Honeypot.pm  view on Meta::CPAN

    $threads->{$DNSfileno}->{read} = \&dns_rcv;		# always armed
    foreach(grep(!/\D/,keys %$threads)) {		# each thread key
      vec($rin,$_,1) = 1 if $threads->{$_}->{read};	# set read selects
      vec($win,$_,1) = 1 if $threads->{$_}->{write};	# set write selects
    }
    $go_listen->{read} = \&newthread;			# re-arm listner if it was busy
    $nfound = select($rout=$rin,$wout=$win,undef,1);	# tick each second

    if ($nfound > 0) {
      do_thread($wout,'write') if $wout;
      do_thread($rout,'read') if $rout;

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

1.119 2018-11-15
- quote fields like envelope-from correctly when writing Received-SPF

1.118 2018-10-29
- fixed potential busy loop with specific DNS responses
- ignore case when comparing answer from DNS to query

1.117 2018-09-24
- fixed mail header when pass_all matched to include reason etc
- add --passall option to samples/spflookup.pl

 view release on metacpan or  search on metacpan

lib/Mail/SpamAssassin/BayesStore/Redis.pm  view on Meta::CPAN

The Redis backend for Bayes can put a Lua scripting support in a Redis
server to good use, improving performance. The Lua support is available
in Redis server since version 2.6. In absence of a Lua support, the Redis
backend uses batched (pipelined) traditional Redis commands, so it should
work with a Redis server version 2.4 (untested), although this is not
recommended for busy sites.

Expiration of token and 'seen' message id entries is left to the Redis
server. There is no provision for manually expiring a database, so it is
highly recommended to leave the setting bayes_auto_expire to its default
value 1 (i.e. enabled).

 view release on metacpan or  search on metacpan

contrib/mimedefang-filter  view on Meta::CPAN

# Set the next one if your mail client cannot handle multiple "inline"
# parts.
$Stupidity{"NoMultipleInlines"} = 0;

# The next lines force SpamAssassin modules to be loaded and rules
# to be compiled immediately.  This may improve performance on busy
# mail servers.  Comment the lines out if you don't like them.
if ($Features{"SpamAssassin"}) {
    spam_assassin_init()->compile_now(1) if defined(spam_assassin_init());

    # If you want to use auto-whitelisting:

 view release on metacpan or  search on metacpan

Summary.pm  view on Meta::CPAN

  my @mail_summaries = $ms->summaries;

=head1 DESCRIPTION

Too busy to read your mail? Subscribe to too many mailing lists? 
Take two folders into the shower? Well, for the busy on the go geek
of today, here is the answer! Get all your messages summarised, to 
save you having to read them, or to read them by which summary looks
better!

=cut

 view release on metacpan or  search on metacpan

doc/toaster-watcher.conf  view on Meta::CPAN

      vpopmail_qmail_ext             = 1
      vpopmail_rebuild_tcpserver_file = 0

    By default, vpopmail updates ~vpopmail/etc/tcp.smtp every time a new
    user is added to the relay table, which is every time a user
    successfully authenticates. This generates a lot of disk i/o on a busy
    mail seerver but is necessary for tcpserver to "see" the update. This is
    not necessary with the Mail::Toaster because we use the MySQL patch to
    tcpserver to check the SQL table directly.

      vpopmail_ip_alias_domains      = 0

doc/toaster-watcher.conf  view on Meta::CPAN

      vpopmail_domain_quotas         = 0
      vpopmail_default_quota         = 100000000S,10000C

    The domain quota feature has been broken on vpopmail almost forever.
    Even when it worked, it introduced extremely high CPU loads on busy mail
    systems. It is to be avoided.

    The default quota option is deprecated in vpopmail 5.4.0 and higher. See
    ~vpopmail/etc/vlimits.default to control default limits.

doc/toaster-watcher.conf  view on Meta::CPAN

      send_log_isoqlog               = 1

    This allows you to choose whether your qmail-send logs will be
    post-processed by isoqlog. This will trigger isoqlog every 5 minutes at
    which time it'll update the pretty HTML pages it generates. This is a
    handy default but if you have a really busy mail server (see if isoqlog
    takes more than a couple seconds to run) with lots of logs, it's better
    to disable this and run isoqlog from cron less frequently.

      send_mailbox_string            = ./Maildir/

 view release on metacpan or  search on metacpan

examples/xmailfolder.pl  view on Meta::CPAN

#   figure why a abnormal exit doesn't cleanup the open mailbox
#   key accelerators are conflicting with each other (Alt-f,c vs. c)
#   actually detect error returns from MailFolder calls
#   do more appropriate error handling in CoreCompose and friends
# SNIGGLES
#   add busy-cursor in appropriate places
#   figure how to get a Shift-(Next|Prior) to move the msg window in the
#      folder window
#   figure out how set width of scrollbars - normal way isn't working

require 5.00397;

 view release on metacpan or  search on metacpan

engine/read_only/install-sh  view on Meta::CPAN

      # to itself, or perhaps because mv is so ancient that it does not
      # support -f.
      {
        # Now remove or move aside any old file at destination location.
        # We try this two ways since rm can't unlink itself on some
        # systems and the destination file might be busy for other
        # reasons.  In this case, the final cleanup might fail but the new
        # file should still install successfully.
        {
          test ! -f "$dst" ||
          $doit $rmcmd -f "$dst" 2>/dev/null ||

 view release on metacpan or  search on metacpan

hoons/arvo/app/dojo.hoon  view on Meta::CPAN

    ++  dy-edit                                         ::  handle edit
      |=  cal/sole-change
      ^+  +>+>
      =^  dat  say  (~(transceive sole say) cal)
      ?:  |(?=(^ per) ?=(^ pux) ?=($~ pro))
        ~&  %dy-edit-busy
        =^  lic  say  (~(transmit sole say) dat)
        (dy-diff %mor [%det lic] [%bel ~] ~)
      (dy-slam(per `dat) /edit u.pro !>((tufa buf.say)))
    ::
    ++  dy-type                                         ::  sole action

 view release on metacpan or  search on metacpan

README.md  view on Meta::CPAN

    cpanm Dist::Zilla
    dzil authordeps | cpanm
    dzil build

While Dist::Zilla takes the busywork and mistakes out of module authorship,
it fails to address the need of XS authors to easily compile XS projects
and run single testcases, rather than the whole test suite.  For this, you
might find the following script handy:

    ./dzil-prove t/04-transform.t  # or any other testcase

 view release on metacpan or  search on metacpan

CREDITS  view on Meta::CPAN

in developing the latest version, not only by cheerfully kicking my lazy butt
from time to time, but also by providing advice, bug-reports, suggestions and
nagging questions, as well as bearing with my countless ranting emails. So,
thank you very much!

Also I want to thank all the ever-busy people on p5p. You guys (and gals) rock!

List still not complete ;o)

Tels <http://bloodgate.com/>

 view release on metacpan or  search on metacpan

examples/c-curve-wx.pl  view on Meta::CPAN

sub OnPaint {
  my ($draw, $event) = @_;
  ### Drawing OnPaint(): $event
  ### foreground: $draw->GetForegroundColour->GetAsString(4)
  ### background: $draw->GetBackgroundColour->GetAsString(4)
  my $busy = Wx::BusyCursor->new;
  my $dc = Wx::PaintDC->new ($draw);

  {
    my $brush = $dc->GetBackground;
    $brush->SetColour ($draw->GetBackgroundColour);

 view release on metacpan or  search on metacpan

lib/Math/SymbolicX/FastEvaluator.pm  view on Meta::CPAN

=head2 PERFORMANCE

Using all this combersome indirection, the evaluation of C<FastEvaluator>
expressions proceeded at a pace of over 200 million tokens per second on my
1.8GHz Core2 laptop which was busy with various desktop tasks at the same time.
A token is a number, variable or operator. Since I was
testing with a string of multiplications, this translates to roughly
100 MFLOPS. You can consider this fast or slow, but compared to Perl
evaluation, this is at least a factor of ten faster. When variables are added into
the picture, the improvement should be even larger.

 view release on metacpan or  search on metacpan

lib/Math/Telephony/ErlangC.pm  view on Meta::CPAN

this must be a defined value, greater or equal to 0.

=item *

B<wait probability> is the probability that a given service request will
be put inside the wait queue, which happens when all servers are busy.

=item *

B<(average) service time> is the (average) time that each server needs to
complete a service request; it's referred to as $mst most of the time

lib/Math/Telephony/ErlangC.pm  view on Meta::CPAN

=over

=item B<$wprob = wait_probability($traffic, $servers);>

Evaluate the probability that a call will have to wait in the queue
because all servers are busy.



=item B<$servers = servers_waitprob($traffic, $wait_probability)>

 view release on metacpan or  search on metacpan

lib/Maypole/Manual/Flox.pod  view on Meta::CPAN

=head1 DESCRIPTION

Friendster, Tribe, and now Google's Orkut - it seems like in early 2004,
everyone wanted to be a social networking site. At the time, I was too
busy to be a social networking site, as I was working on my own project
at the time - Maypole. However, I realised that if I could implement a
social networking system using Maypole, then Maypole could probably do
anything.

I'd already decided there was room for a free, open-source networking

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

        When using the max_lag configuration, if max_lag_retries was reached - the reported number tries were incorrect.
        Fixed up the api->list function not continuing due to lack of rawcontinue parameter that is needed after MediaWiki 1.26.
        Thanks to Derbeth for the bug reports.

0.40    2014-09-13
        Apologies for the lack of updates and the speed to implement some fixes but I have been busy on other projects.
        Edit token code has been reworked somewhat to make it simpler, and a bugfix applied for an issue with downloading
        images over https using the buildin Download() function.

0.39    2012-05-20
        Added automatic support for handling tokens in the MediaWiki::API->Edit function for (Un)watch, Send e-mail

 view release on metacpan or  search on metacpan

src/libmemcached/build-aux/install-sh  view on Meta::CPAN

      # to itself, or perhaps because mv is so ancient that it does not
      # support -f.
      {
	# Now remove or move aside any old file at destination location.
	# We try this two ways since rm can't unlink itself on some
	# systems and the destination file might be busy for other
	# reasons.  In this case, the final cleanup might fail but the new
	# file should still install successfully.
	{
	  test ! -f "$dst" ||
	  $doit $rmcmd -f "$dst" 2>/dev/null ||

 view release on metacpan or  search on metacpan

lib/MetaTrans.pm  view on Meta::CPAN

Returns current state of the translator. Possible values are

    VALUE       MEANING
    ---------   --------------------------------------------------------
    "ok"        successfully finished a translation (initial state, too)
    "busy"      working on a translation
    "timeout"   a timeout occured when querying an online translator
    "error"     unknown error occured when queryign an online translator

=cut

lib/MetaTrans.pm  view on Meta::CPAN

C<$dest_lang_code> language simultaneously on all enabled translators
(plug-ins), which support this translation direction. The method returns
true value on success, false on error. Use C<get_translation> method for
retrieving the results of particular translations.

The method sets the state of all plug-ins to C<"busy">. See C<get_state>
method.

There are two ways of performing parallel run. If C<$options{tk_safe}> is
undefined or set to false value, then a child process is forked for every
translator to be used and C<translate> method is called. This is generally

lib/MetaTrans.pm  view on Meta::CPAN

                }
            }
            until defined $pid;
        }

        ${$self->{state}}{$translator} = "busy";

        if ($pid)
        {
            # parent
            push @{$self->{pids}}, $pid;

lib/MetaTrans.pm  view on Meta::CPAN

}

=item $mt->stop_translators

Stop all running plug-ins. This simply kills all running child processes.
The correspondent translators will end in the C<"busy"> state.

=cut

sub stop_translators
{

 view release on metacpan or  search on metacpan

lib/Metabrik/Client/Tcpdump.pm  view on Meta::CPAN

      }
      $self->log->debug("capture: read returned");

      # We need to reset the timeout, otherwise read() will 
      # always return immediately after each call, causing a full CPU 
      # to become busy. Yes, read() is blocking until a timeout occurs.
      if ($self->has_timeout) {
         $self->reset_timeout;
      }

      last if $count && $read_count >= $count;

 view release on metacpan or  search on metacpan

lib/Minion/Worker.pm  view on Meta::CPAN

sub info { $_[0]->minion->backend->list_workers(0, 1, {ids => [$_[0]->id]})->{workers}[0] }

sub new {
  my $self = shift->SUPER::new(@_);
  $self->on(busy => sub { sleep 1 });
  return $self;
}

sub process_commands {
  my $self = shift;

lib/Minion/Worker.pm  view on Meta::CPAN

  my $jobs = $self->{jobs} ||= [];
  @$jobs = map { $_->is_finished && ++$status->{performed} ? () : $_ } @$jobs;

  # Job limit has been reached or worker is stopping
  my @extra;
  if    ($self->{finished} || ($status->{jobs} + $status->{spare}) <= @$jobs) { return $self->emit('busy') }
  elsif ($status->{jobs} <= @$jobs) { @extra = (min_priority => $status->{spare_min_priority}) }

  # Try to get more jobs
  my $tasks = desired_tasks($status->{limits}, [keys %{$self->minion->tasks}], [map { $_->task } @$jobs]);
  return unless @$tasks;

lib/Minion/Worker.pm  view on Meta::CPAN

=head1 EVENTS

L<Minion::Worker> inherits all events from L<Mojo::EventEmitter> and can emit the following new ones.

=head2 busy

  $worker->on(busy => sub ($worker) {
    ...
  });

Emitted in the worker process when it is performing the maximum number of jobs in parallel.

  $worker->on(busy => sub ($worker) {
    my $max = $worker->status->{jobs};
    say "Performing $max jobs.";
  });

=head2 dequeue

lib/Minion/Worker.pm  view on Meta::CPAN

  my $worker = Minion::Worker->new;
  my $worker = Minion::Worker->new(status => {foo => 'bar'});
  my $worker = Minion::Worker->new({status => {foo => 'bar'}});

Construct a new L<Minion::Worker> object and subscribe to L</"busy"> event with default handler that sleeps for one
second.

=head2 process_commands

  $worker = $worker->process_commands;

 view release on metacpan or  search on metacpan

t/role_conflict_method_resolved.t  view on Meta::CPAN

        roles => [qw( Camper BaseballPro )],
    );

    sub pitch {
        my ($self) = @_;
        return "I'm so busy";
    }
}

{
    package BusyDude;

t/role_conflict_method_resolved.t  view on Meta::CPAN

}

package main;

my $dude = BusyDude->new;
is($dude->pitch, "I'm so busy", '');

done_testing();

 view release on metacpan or  search on metacpan

Vgetty.pm  view on Meta::CPAN

I<Voice modem> is a special kind of modem, which (besides the normal
data and/or fax mode) can communicate also in voice mode. It means
it can record sounds it hears from the phone line to the file,
Play-back recorded files, it can beep to the line, and it can detect
various standard sounds coming from the line (busy tone, silence,
dual tone modulation frequency (DTMF) keypad tones, etc).
An example of the voice modem can be the ZyXEL U1496, US Robotics
Sportster (not Courier), etc.

To use this software with the voice modem you need to have the

Vgetty.pm  view on Meta::CPAN

The B<vgetty> records the voice it can hear on the line to the given file.
It uses the raw modem data format (which can be re-played using the
B<play> subroutine). B<vgetty> changes its state to "RECORDING" and
you need to manually stop the recording using the B<stop> method
after some time (or, you can set B<autostop> and wait for any event
- silence, busy tone, etc).

=item wait($seconds)

The modem waits for a given number of seconds. Changes its state to
"WAITING" and returns "READY" after the wait is finished. Example:

Vgetty.pm  view on Meta::CPAN

The modem detected a bong tone on the line.

=item BUSY_TONE

The modem detected busy tone on the line (when dialing to the busy
number or when caller finished the call).

=item CALL_WAITING

Defined in IS-101 (I think it is when the line receives another call-in

Vgetty.pm  view on Meta::CPAN

		 " | mail -s 'New voice message' $voicemaster";
        exit 0;

See the B<examples/answering_machine.pl> in the source distribution,
which contains a more configurable version of the above text.
It first sets the event handlers for the case of busy tone (the caller
hangs up) or silence (the caller doesn't speak at all). The handler
stops B<vgetty> from anything it is currently doing and sets the $finish
variable to 1. Then the reception of the events is enabled and 
the welcome message is played. Then the answering machine beeps
and starts to record the message. Note that we need to check the

 view release on metacpan or  search on metacpan

lib/Module/Advisor.pm  view on Meta::CPAN

    ['Mouse' => '>= 1.07, < 1.12', 'Memory leaks in trigger'],
    ['Text::Xslate' => '< 1.0011', '&apos; bug.'],
    ['Text::Xslate' => '< 1.5021', 'segv in "render" recursion call'],
    ['Text::Xslate' => '< 1.6001', 'possibly memory leaks on VM stack frames. see https://github.com/xslate/p5-Text-Xslate/issues/71'],
    ['Text::Xslate' => '< 2.0005', 'Nested WRAPPER broken https://github.com/xslate/p5-Text-Xslate/issues/79'],
    ['Furl' => '< 0.39', 'unexpected eof in reading chunked body. It makes busy loop.'],
    ['AnyEvent::MPRPC' => '< 0.15', 'switch to Data::MessagePack::Stream'],
    ['Data::MessagePack' => '< 0.46', 'fixed unpacking issue on big-endian system.'],
    ['Data::MessagePack' => '< 0.39', 'packing float numbers fails on some cases'],
    ['FCGI::Client' => '< 0.06', 'fixed large packet issue'],
    ['Starlet' => '< 0.12', 'fix infinite loop when connection is closed while receiving response content'],
    ['Starman' => '< 0.2014', '$res->[1] is broken after output (This is actualized with Plack::Middleware::AccessLog::Timed) https://github.com/miyagawa/Starman/pull/31'],
    ['Starman' => '< 0.1006', 'Fixed 100% CPU loop when an unexpected EOF happens'],
    ['Twiggy' => '< 0.1000', 'busy loop'],
    ['Teng', '< 0.14', 'fixed deflate bug.'],
    ['DBIx::Skinny', '< 0.0742', 'txn_scope bug fixed'],
    ['DBIx::TransactionManager', '< 1.11', 'not execute begin_work at AutoCommit=0.'],
    ['HTTP::MobileAgent' => '< 0.36', 'new x-up-devcap-multimedia(StandAloneGPS) support'],
    ['HTTP::MobileAgent' => '< 0.35', 'Updated $HTMLVerMap and $GPSModelsRe in DoCoMo.pm'],

 view release on metacpan or  search on metacpan

lib/Data/Fake/CPAN.pm  view on Meta::CPAN

  beloved beneficial better best bewitched big big-hearted biodegradable
  bite-sized bitter black black-and-white bland blank blaring bleak blind
  blissful blond blue blushing bogus boiling bold bony boring bossy both
  bouncy bountiful bowed brave breakable brief bright brilliant brisk broken
  bronze brown bruised bubbly bulky bumpy buoyant burdensome burly bustling
  busy buttery buzzing calculating calm candid canine capital carefree careful
  careless caring cautious cavernous celebrated charming cheap cheerful cheery
  chief chilly chubby circular classic clean clear clear-cut clever close
  closed cloudy clueless clumsy cluttered coarse cold colorful colorless
  colossal comfortable common compassionate competent complete complex
  complicated composed concerned concrete confused conscious considerate