text:
Norfolk, Topographical History
An Essay Towards A Topographical History of the County of Norfolk: Volume 10
Launditch Hundred: Litcham
An Essay Towards A Topographical History of the County of Norfolk: Volume 10. Originally published by W Miller, London, 1809.
LITCHAM.
Netherhall Manor.
East Hall
Rectors.
Part of this town was a beruite, or manor depending on the capital manor or honour of Mileham, held by Stigand Archbishop of Canterbury, a lay fee in his own right, and was deprived of it by the Conqueror, and farmed of him by William de Noiers; 4 carucates of land belonged to it, 9 villains and 11 borderers, and 5 servi, with 4 acres of meadow, 2 carucates in demean, and 9 amongst the tenants, only 5 at the survey, but the rest might be recovered, also 2 socmen with 4 acres and a half of land, one runcus, one cow, and 16 swine, 104 sheep, and 20 goats, and was valued in Mileham. (fn. 1)
Soon after this, Alan, son of Flaald, to whom the Conqueror granted the manor of Mileham, had also this with it as an appendix to, or part of, the said manor. This Alan was ancestor of the noble family of the Fitz Alans Earls of Arundel, and lords this manor and of Mileham, to which town, for an account of them, I refer the reader.
Alan granted it to Sewald, with the hundred of South-Greenhow, and Launditch, to hold of him and his heirs; of this Sewald was John Le Strange, descended, (as may be seen in the hundred of Launditch,) who in the 52d of Henry III. held here one fee, was of age, and not a knight; and in the 55th of Henry III. having impleaded the rector of Litcham for keeping the evidences of his lordship from him, released the action by deed dated at Knokyn, which shows that this family was related to that of Knokyn, in Shropshire; by Isabella his wife he had two sons, John and Ralph; John, the eldest, married Clementia, relict (as it is said) of Jordan de Sackvile, and daughter of Sir William de Burgh.
In the 14th of Edward I. Baldwin de Frevyle, appears to have some interest herein, and sued his bailiff, Richard de Clerk, to give him an account of what he had received here, in Wellingham, and Wesenham; and in the same year he impleaded John le Strange de la Marche, to acquit him of the service and payment of 15s. scutage, which Robert Burnel Bishop of Bath and Wells demanded of him for the manor which he held for the life of the said John, belonging to Richard Fitz Alan Earl of Arundel, then in the custody of that Bishop, his guardian.
The jury, in the 15th of that King, find that the said Baldwin de Frevyle claimed frank pledge by the view of the King's bailiff, assise, weyf and stray in this manor; and in the 20th year of the said King a fine was levied between John son of Ralph L'Strange of Lutcham and Isabell his wife, querents, and John de Waltham, parson of Snoring Parva, and Richard de Sutton, their trustees, deforciants of several messuages, 140 acres of land, a mill, 15 acres of meadow, 15 of marsh, 15 of heath, 29s. 8d. rent in Lucham, Mileham, Titeshale, Stanford and Bittering Parva, settled on John Waltham, who reconveyed them to John, son of Ralph and Isabel, for their lives, remainder to John (son of the aforesaid John) and Clementia his wife.
This John, son of John, on whom the remainder abovementioned was settled, died, as appears from the eschaet rolls, in the 33d of Edward I. and Ralph was then found to be his brother and heir; but by a fine levied in the 2d of Edward II. John, brother of Ralph, left a son of his own name, as may be seen in Wellingham, and it seems to be entailed on Ralph.
Of this family was Alice, daughter of Sir John L'Strange, to whom Sir John Gedding sold, for 63 marks, all the messuages, lands, homages, rents, &c. in this town, by deed sans date.
After this I find it in the family of De Felton, who had an interest here in the reign of Henry III. when Robert de Felton held half a fee of John le Strange de la Marche, that is, of the marshes in Wales, &c. and John, of the Fitz Alans, lords of Mileham; and in the 25th year of Edward I. Robert de Felton had the grant of a mercate every week at his manor of Lucham, and a fair yearly on the day and morrow of the feast of All-Saints, with free-warren: this seems to be that Robert who was knighted at Westminster about this time, with 300 young gentlemen, sons of noblemen and knights, at the feast of Pentecost, with great solemnity, at the high altar in the abbey church, on the creation of the King's son, Prince of Wales, who was knighted also with them; in the roll he is styled Robert, son of Robert, son of Pagan; and John de Felton was lord in the 9th of Edward II.
Sir Thomas Felton, sen. granted in the 5th of Edward III. to Richard de Lambeth, citizen of London, 40l. per ann. out of his manor of Lutcham, and in the 20th of that King. Sibill de Felton was found to hold half a fee of the Earl of Arundel; and Sir Thomas de Felton, Knt. of the Garter, died seized of it in or about the 4th of Richard II. with the advowson of the church, and Mary, his eldest daughter, by Joan his wife, was found to be married to Sir Edmund Hengrave, and Sibilla to Sir Thomas de Morley: Sir Thomas Felton was governour of Aquitain in France, and taken prisoner in 1377.
It does not appear that either Hengrave or Morley had any interest in this lordship.
Joan de Felton, (fn. 2) widow of Sir Thomas, held it in the 4th of Henry IV. by half a fee, of the Earl of Arundel, and on her death (as I take it) it came to Cecilia, daughter of John Breton, Esq. of Wychingham Magna, by Mary his wife, daughter of Sir Hamon de Felton; who released to Sir Thomas Erpingham and his heirs, all her right in the manor of Felton's called Netherhall, in Litcham, and in the advowson of the church, in the 10th of the aforesaid King.
In the pedigree of the Wodehouses of Kimberley, (fn. 3) Sir Edward Wodehouse, who lived in the reign of Richard II. Ao. 1378, is said to have married a daughter and coheir of - - - - Erpingham," and that one of the family married Joan, a daughter and coheir of Sir Thomas Erpingham, who brought the manor of Netherhall in this town into the family, is certain; but as Sir Thomas Erpingham was living in the reigns of Henry V. and VI. and died in 1426, it could not be his daughter and coheir Joan, who married the aforesaid Sir Edward Wodehouse.
John Wodehouse, Esq. famous in the wars of France, at Agincourt, &c. was an intimate friend and fellow soldier with Erpingham, being grandson of Sir Edward Wodehouse aforesaid, and died 1439.
This lordship was given by Sir Edward Wodehouse, Bart. in the reign of Charles the 2d, to Edmund his second son, on whose death, in 1727, it came to Sir John Wodehouse, and his son Sir Armine Wodehouse is lord.
Was in the days of King Edward, the lordship of Turchetel, but on the Conquest was granted to Hermerus de Ferrarijs, ancestor of the Lords Bardolf, barons of Wirmegay in Norfolk, when it contained 3 carucates of land, 3 villains, 3 borderers, 4 servi, 8 acres of meadow 2 carucates in demean, one amongst the tenants, &c. a mill, and 3 socmen held 4 acres and one virgate of land, &c. the moiety of the church, with 4 acres, and there belonged to the lord half a carucate of land, 2 borderers, the 4th part of a mercate, and William held it under Hermerus, and half a carucate, with 2 acres of meadow, &c. in Thorp, (Wesenham,) valued at 50s. and 10s. over: the whole was 8 furlongs long, 6 broad, including a manor in Roughum, and paid 7d. gelt. (fn. 4)
This lordship of the Lord Bardolf extended also into Dunham Magna, and East Lexham: that part of it which was in this town seems to be held by Sir John Gedding, and conveyed by him to Alice, daughter of Sir John Strange, for 63 marks, by deed sans date, as I have above mentioned.
In the 8th of Richard II. Thomas Gardiner, Esq lord of Gissing, held in right of his wife Cecilia, daughter of John Breton, Esq. and Mary his wife above mentioned a fourth part of this lordship, and in the 9th of the said King, a fine was levied, wherein John Petere of Long-Stratton, and Claricia, his wife, convey to Joan, widow of Sir Thomas de Felton, John de Waltham, and John Churchman, her trustees the manor of East Hall in Lutcham, and lands in Titleshale, from the heirs of Claricia, and in 18th of the said reign, the Lord Bardolf was found to hold in this town, East Lexham, Dunham Magna, Elingham Magna, and Kempston 5 fees.
Sir John Tiptoft had in right of his wife Jocosa, the third part of this manor 180, acres of land, 4 of pasture, the third part of a watermill, with rents of assise, and perquisites of court, by the 40th part of a fee: the lady Jocosa was a daughter and coheir of Edward Cherlton Lord Powys, by Alianore his wife, daughter of Thomas, and sister, and coheir to Edmund Holland Earl of Kent, widow of Roger Mortimer Earl of March, Joan, the other daughter and coheir of Edward Lord Powys, being married to Sir John Grey.
After this it came to Sir Thomas Erpingham, who was lord of the whole, and by his daughter and coheir Joan, to - - - - - - Wodehouse, and Sir Edward Wodehouse, by a fine levied in the 18th of Edward IV. was lord of East Hall and Nether Hall.
Temporalities of the the prioress of Carrow in 1428, 6d.; of Westcacre 6d.; of Castleacre 6d.
Agnes, widow of Ralph L'Strange of Lutham, gave to Castleacre priory 2s. rent per ann. payable by Edrich of Southacre, confirmed by John her son, sans date.
Benedict, prior of Castleacre, granted to Michael Harold of Titleshale 6 acres of land in Lucham, paying 3s. per ann.—witnesses, Alexander de Acra, Reyner de Acra, &c.
The town takes its name from the river Leche, or Litche, that runs by it, as Lechelade in Gloucestershire, &c.
The Church is dedicated to All-Saints, is a neat, regular pile, with a nave covered with reed, a north and south isle, and a chancel covered with lead; at the west end of the nave, a square tower of brick, with coins of free-stone, and embattled, with a clock and dial, built by Mathew Halcot, a tanner, who new cast the bells, and gave the clock.
In the nave lie several gravestones;
In memory of Philippa, wife of John Baly, and relict of Edward Girling, Gent. who died August 24, 1752, aged 52.
For, John Neale, Gent. son of John Neale, merchant in Wisbeach, and uncle to the late excellent rector of this parish, who died Feb. 12, 1727, aged 66.
In memory of Hellen Lawrence, widow, who died Jan. 16, 1741, aged 88 years, and near to her lyeth Mathew Helcot, and Franc. Lawrence, Gent. her two husbands.
For, Mathew Halcot, Gent. who died 1688, æt. 36, with a Latin inscription, and one for Mat. Halcot, Gent. who died August 7, 1707, aged 34.
Against the wall of the tower, fronting the nave, a mural monument of marble;
In memory of John Glover, Gent. erected by Martha his real sorrowful widow, who to perpetuate his memory has given 40s. per ann. payable out of lands in this parish, by the minister and church-wardens to the poor thereof, on the feast day of St. John the Evangelist, he died May 23, 1741, in his 48th year; with these arms on the summit, sable, a fess embattled, ermin, between three crescents, argent.
In the chancel a stone
In memory of John Wastell Gent. of this parish, who died April 19, 1710, aged 73.—For John Wastell, Gent. who died July 13, 1732, aged 54.
One,
In memory of Edward Girling, late of Litcham, Gent. son of Edward and Ann Girling of Norwich, who died March 27, 1736, aged 30.—Vixit Legis municipalis peritus, in praxi sagax, integer, erga Deum pius, conjugis amans, erga parentes moriger amicis gratus, omnibus flebilis; and this shield, argent, on a bend, per pale, gules and azure, between two bendlets engrailed, sable, three lis of the first.
In the rails of the communion table, a grave-stone
In memory of William Neale, the late worthy rector of this parish, and vicar of Kempston, son of John Neale, (fn. 5) late rector of Mileham, and Elizabeth his wife died June 30, 1741. aged 56.
An altar monument in the church yard;
Reliquiœ Joh. Halcot, Gen. qui mortem obt. apud Lenne, 22 die Martij, A. D. 1678.
Another;
Corpus Matth. Halcot, Gent. qui hanc vitam meliori commutavit 30 July, 1675, œt. suœ 75, cujus sumptibus hoc campanile penitus constructum fuit, &c. 1669.
Hic jacet corpus Joh. Halcot, Armig. de Medio Temple, Londinensi quond. socij filij Matt. Halcot. &c. qui dedit lagenam, et calicem argent. altari hujus ecolesiœ, natus 1648, obt. - - - - - at. 33.
The ancient valor of the church of Litcham, with the portion of the prior of Castleacre, was 10 marks, Peter-pence 2d. ob.; present valor is 9l. 2s. 6d.
1319, Roger Bolewyk, instituted, presented by Sir John Felton.
1349, William Knyghtele, by the lady Sibilla Felton.
1379, Richard Rokel, by Sir Stephen Hales, Knt. and William de Rudham.
1422, Richard Smyth, by Sir Thomas Erpingham, Knt.
1425, Thomas Sharp, by ditto.
1425, Thomas Middleton.
William Short.
1469, John Aylware, by Roger Townsend, Gent.
1474, Mr. John Bomor, by ditto.
1508, Laur. Bomor, by Sir Thomas Wodehouse.
1540, John Chadwick, by Roger Wodehouse.
1554, Richard Russell, by Sir Roger Wodehouse.
1556, John Wynder, by ditto.
1559, John Chadwick, by ditto.
1571, Richard Pachet, A.M. by the assignees of Sir Roger Wodehouse.
1573, Robert Johnson, by Roger Wodehouse, Esq.
1611, Robert Painter, by Sir Thomas Wodehouse. Richard Lacy.
1617, Edward Pagrave, by ditto.
In 1642, Luke Skippon compounded as rector for his first fruits.
Thomas Wilson occurs rector in 1662.
1681, Henry Tyrell, A.M. by Edmund Wodehouse, Esq.
1684, Franc. Amias, by ditto.
1688, John Cleaver, by ditto.
1741, Peter Smith, by Sir John Wodehouse, Bart.
Dame Mary Woodhouse, relict of Sir Roger, in 1634, left 3l. per ann. to the prior, and William Allee 40s. per ann.
In this church was the guild of All-Saints, and that of St. John Baptist; the light of our Lady, and that of the resurrection.
On the common in this parish was anciently an hermitage, and Thomas Cannon was hermit here.
1. Tre Stigandi Epi. quas custodit W. de Noiers. — Huic manerio (Mileham) semp. jacet i beruita Licham, iiii car. tre. semp. ix vill. et xi bord. et v ser. et iiii ac. p'ti. semp. ii car. in d'nio. tnc. et p. ix car. hom. mo. v et alie possent restaurari. et ii soc iiii ac. tre. et dim. semp. i. r. et i an. et xvi porc. et ciiii ov. et xx cap.
2. Joan was daughter and coheir of Sir Richard Walkefare, Knt.
3. See Blomfield's Hist. of Norf. vol. ii. ad fin.
4. Terre Hermeri—Letham ten. Turchetel lib. ho. T. R. E. iii. car. tre. p. man. tc. et p' iiii vill. mo. iii tc. et p' iiii bord. mo. iii tc. et p' iiii serv. mo. viii ac. pti. sep. ii car. in d'nio. et i car. hom. silva. vii por. et semp. i molin. et iii soc. iiii ac. terre et i virgata. tc. ii runc. tc ix an. modo. iii sep. xxvii porc. tc. cc ov. mo. cc. xx dim. ecc'lia iiiiac. huic manerio jacet dim, car. terre sep. ii bord. et quarta pars uni'mercati. mo. ten. Will. tc. i car. mo. dim. car. et. ii pti. sep. xxv ov. et ii porc. hoc est in Torp. tc. et p' val. xl. sol. mo. l et sup. eu' x sol.— Totu' Lecham vii quar in longo et vi in lat. quicu'q; ibi teneat, et viid. et i obsolu' de gelto.
5. This John left 2s. weekly to poor persons, and their dwelling-house.


text:
El transporte ARA San Julián (B-7) de la Armada Argentina, originalmente USA FS-281, fue un carguero costero diseño 381 construido para el Ejército de los Estados Unidos.

Construcción e historia
El FS-281 fue un carguero costero diseño 381 construido por Wheeler Shipbuilding de Whitestone, Nueva York. Fue botado en 1944 y entregado al Ejército en 1945.

Fue adquirido en 1947 por la Armada Argentina como ARA San Julián. Estuvo en servicio de 1947 a 1990. Radiado, fue entregado y puesto como escollera en Puerto Rosales.

Véase también
 Anexo:Buques auxiliares de Argentina

Referencias

Cargueros de Argentina
Buques auxiliares de Argentina
Argentina en 1947

redpajama_set_name: RedPajamaWikipedia


Cheap Iggy Black Leather Look Panel Leggings Black women Online : Women Clothing,50% off!
Vamp up your legging game with the 'Iggy' leather look leggings featuring a mid-waist style, super soft fabric and a panel design. Add some killer knee high boots and slayin' tee to finish off this look!
View the full iKrush Size Guide to find out which size is right for you!


Me is the objective case of the first person singular pronoun I, and us is the objective case of the first person plural pronoun we.
She always wrote in the first person.
The sentence "I was born in Maine" is written in the first person.
What made you want to look up first person? Include any comments and questions you have about this word.


text:
/*	$NetBSD: smtpd_chat.c,v 1.1.1.3 2013/01/02 18:59:09 tron Exp $	*/

/*++
/* NAME
/*	smtpd_chat 3
/* SUMMARY
/*	SMTP server request/response support
/* SYNOPSIS
/*	#include <smtpd.h>
/*	#include <smtpd_chat.h>
/*
/*	void	smtpd_chat_query(state)
/*	SMTPD_STATE *state;
/*
/*	void	smtpd_chat_reply(state, format, ...)
/*	SMTPD_STATE *state;
/*	char	*format;
/*
/*	void	smtpd_chat_notify(state)
/*	SMTPD_STATE *state;
/*
/*	void	smtpd_chat_reset(state)
/*	SMTPD_STATE *state;
/* DESCRIPTION
/*	This module implements SMTP server support for request/reply
/*	conversations, and maintains a limited SMTP transaction log.
/*
/*	smtpd_chat_query() receives a client request and appends a copy
/*	to the SMTP transaction log.
/*
/*	smtpd_chat_reply() formats a server reply, sends it to the
/*	client, and appends a copy to the SMTP transaction log.
/*	When soft_bounce is enabled, all 5xx (reject) reponses are
/*	replaced by 4xx (try again). In case of a 421 reply the
/*	SMTPD_FLAG_HANGUP flag is set for orderly disconnect.
/*
/*	smtpd_chat_notify() sends a copy of the SMTP transaction log
/*	to the postmaster for review. The postmaster notice is sent only
/*	when delivery is possible immediately. It is an error to call
/*	smtpd_chat_notify() when no SMTP transaction log exists.
/*
/*	smtpd_chat_reset() resets the transaction log. This is
/*	typically done at the beginning of an SMTP session, or
/*	within a session to discard non-error information.
/* DIAGNOSTICS
/*	Panic: interface violations. Fatal errors: out of memory.
/*	internal protocol errors.
/* LICENSE
/* .ad
/* .fi
/*	The Secure Mailer license must be distributed with this software.
/* AUTHOR(S)
/*	Wietse Venema
/*	IBM T.J. Watson Research
/*	P.O. Box 704
/*	Yorktown Heights, NY 10598, USA
/*--*/

/* System library. */

#include <sys_defs.h>
#include <setjmp.h>
#include <unistd.h>
#include <time.h>
#include <stdlib.h>			/* 44BSD stdarg.h uses abort() */
#include <stdarg.h>

/* Utility library. */

#include <msg.h>
#include <argv.h>
#include <vstring.h>
#include <vstream.h>
#include <stringops.h>
#include <line_wrap.h>
#include <mymalloc.h>

/* Global library. */

#include <smtp_stream.h>
#include <record.h>
#include <rec_type.h>
#include <mail_proto.h>
#include <mail_params.h>
#include <mail_addr.h>
#include <post_mail.h>
#include <mail_error.h>
#include <smtp_reply_footer.h>

/* Application-specific. */

#include "smtpd.h"
#include "smtpd_expand.h"
#include "smtpd_chat.h"

#define STR	vstring_str
#define LEN	VSTRING_LEN

/* smtp_chat_reset - reset SMTP transaction log */

void    smtpd_chat_reset(SMTPD_STATE *state)
{
    if (state->history) {
	argv_free(state->history);
	state->history = 0;
    }
}

/* smtp_chat_append - append record to SMTP transaction log */

static void smtp_chat_append(SMTPD_STATE *state, char *direction,
			             const char *text)
{
    char   *line;

    if (state->notify_mask == 0)
	return;

    if (state->history == 0)
	state->history = argv_alloc(10);
    line = concatenate(direction, text, (char *) 0);
    argv_add(state->history, line, (char *) 0);
    myfree(line);
}

/* smtpd_chat_query - receive and record an SMTP request */

void    smtpd_chat_query(SMTPD_STATE *state)
{
    int     last_char;

    /*
     * We can't parse or store input that exceeds var_line_limit, so we skip
     * over it to avoid loss of synchronization.
     */
    last_char = smtp_get(state->buffer, state->client, var_line_limit,
			 SMTP_GET_FLAG_SKIP);
    smtp_chat_append(state, "In:  ", STR(state->buffer));
    if (last_char != '\n')
	msg_warn("%s: request longer than %d: %.30s...",
		 state->namaddr, var_line_limit,
		 printable(STR(state->buffer), '?'));

    if (msg_verbose)
	msg_info("< %s: %s", state->namaddr, STR(state->buffer));
}

/* smtpd_chat_reply - format, send and record an SMTP response */

void    smtpd_chat_reply(SMTPD_STATE *state, const char *format,...)
{
    va_list ap;
    int     delay = 0;
    char   *cp;
    char   *next;
    char   *end;

    /*
     * Slow down clients that make errors. Sleep-on-anything slows down
     * clients that make an excessive number of errors within a session.
     */
    if (state->error_count >= var_smtpd_soft_erlim)
	sleep(delay = var_smtpd_err_sleep);

    va_start(ap, format);
    vstring_vsprintf(state->buffer, format, ap);
    va_end(ap);

    if (*var_smtpd_rej_footer
	&& (*(cp = STR(state->buffer)) == '4' || *cp == '5'))
	smtp_reply_footer(state->buffer, 0, var_smtpd_rej_footer,
			  STR(smtpd_expand_filter), smtpd_expand_lookup,
			  (char *) state);

    /* All 5xx replies must have a 5.xx.xx detail code. */
    for (cp = STR(state->buffer), end = cp + strlen(STR(state->buffer));;) {
	if (var_soft_bounce) {
	    if (cp[0] == '5') {
		cp[0] = '4';
		if (cp[4] == '5')
		    cp[4] = '4';
	    }
	}
	/* This is why we use strlen() above instead of VSTRING_LEN(). */
	if ((next = strstr(cp, "\r\n")) != 0) {
	    *next = 0;
	    if (next[2] != 0)
		cp[3] = '-';			/* contact footer kludge */
	    else
		next = end;			/* strip trailing \r\n */
	} else {
	    next = end;
	}
	smtp_chat_append(state, "Out: ", cp);

	if (msg_verbose)
	    msg_info("> %s: %s", state->namaddr, cp);

	smtp_fputs(cp, next - cp, state->client);
	if (next < end)
	    cp = next + 2;
	else
	    break;
    }

    /*
     * Flush unsent output if no I/O happened for a while. This avoids
     * timeouts with pipelined SMTP sessions that have lots of server-side
     * delays (tarpit delays or DNS lookups for UCE restrictions).
     */
    if (delay || time((time_t *) 0) - vstream_ftime(state->client) > 10)
	vstream_fflush(state->client);

    /*
     * Abort immediately if the connection is broken.
     */
    if (vstream_ftimeout(state->client))
	vstream_longjmp(state->client, SMTP_ERR_TIME);
    if (vstream_ferror(state->client))
	vstream_longjmp(state->client, SMTP_ERR_EOF);

    /*
     * Orderly disconnect in case of 421 or 521 reply.
     */
    if (strncmp(STR(state->buffer), "421", 3) == 0
	|| strncmp(STR(state->buffer), "521", 3) == 0)
	state->flags |= SMTPD_FLAG_HANGUP;
}

/* print_line - line_wrap callback */

static void print_line(const char *str, int len, int indent, char *context)
{
    VSTREAM *notice = (VSTREAM *) context;

    post_mail_fprintf(notice, " %*s%.*s", indent, "", len, str);
}

/* smtpd_chat_notify - notify postmaster */

void    smtpd_chat_notify(SMTPD_STATE *state)
{
    const char *myname = "smtpd_chat_notify";
    VSTREAM *notice;
    char  **cpp;

    /*
     * Sanity checks.
     */
    if (state->history == 0)
	msg_panic("%s: no conversation history", myname);
    if (msg_verbose)
	msg_info("%s: notify postmaster", myname);

    /*
     * Construct a message for the postmaster, explaining what this is all
     * about. This is junk mail: don't send it when the mail posting service
     * is unavailable, and use the double bounce sender address to prevent
     * mail bounce wars. Always prepend one space to message content that we
     * generate from untrusted data.
     */
#define NULL_TRACE_FLAGS	0
#define NO_QUEUE_ID		((VSTRING *) 0)
#define LENGTH	78
#define INDENT	4

    notice = post_mail_fopen_nowait(mail_addr_double_bounce(),
				    var_error_rcpt,
				    INT_FILT_MASK_NOTIFY,
				    NULL_TRACE_FLAGS, NO_QUEUE_ID);
    if (notice == 0) {
	msg_warn("postmaster notify: %m");
	return;
    }
    post_mail_fprintf(notice, "From: %s (Mail Delivery System)",
		      mail_addr_mail_daemon());
    post_mail_fprintf(notice, "To: %s (Postmaster)", var_error_rcpt);
    post_mail_fprintf(notice, "Subject: %s SMTP server: errors from %s",
		      var_mail_name, state->namaddr);
    post_mail_fputs(notice, "");
    post_mail_fputs(notice, "Transcript of session follows.");
    post_mail_fputs(notice, "");
    argv_terminate(state->history);
    for (cpp = state->history->argv; *cpp; cpp++)
	line_wrap(printable(*cpp, '?'), LENGTH, INDENT, print_line,
		  (char *) notice);
    post_mail_fputs(notice, "");
    if (state->reason)
	post_mail_fprintf(notice, "Session aborted, reason: %s", state->reason);
    post_mail_fputs(notice, "");
    post_mail_fprintf(notice, "For other details, see the local mail logfile");
    (void) post_mail_fclose(notice);
}

redpajama_set_name: RedPajamaGithub


text:
Thomas drops 31 on Magic to lead Hurricanes to Game 3 win
Moncton Magic (1-2, 1-1) 28 17 25 21 91
Halifax Hurricanes (2-1, 1-1) 33 18 24 22 97
- Paul Morris photo
Pts: Trey Kell - 23
Reb: Trey Kell - 10
Ast: Billy White - 5
Pts: Terry Thomas - 31
Reb: Terry Thomas - 9
Ast: Cliff Clinkscales - 10
The Halifax Hurricanes took a 2-1 lead in the NBL Canada Atlantic Finals on Saturday night at Scotiabank Centre in Halifax, beating the Moncton Magic 97-91.
Terry Thomas put together a monstrous offensive game, scoring 31 points on 11-17 shooting, including six from three. That was on top of his nine rebounds, four assists, two blocks and a steal.
Behind Thomas, the Hurricanes put together a very efficient game, shooting 48.1 per cent from the field and 42.9 per cent from three. The also limited the Magic to just three made threes on the night.
Until the fourth quarter, not one other Hurricane cracked double-digit points, until Mike Poole exploded for 14 points in the fourth to lead the Hurricanes across the finish line. He finished with 16 points and eight boards.
Cliff Clinkscales put together a vintage performance. He had nine points and 10 assists.
The Moncton Magic were led by Trey Kell with 23 points. Four Magic players scored in double digits in the loss.
The series continues on Monday, April 29 with Game 4 at Scotiabank Centre where the Hurricanes will have a chance to go up 3-1 at home. The game is scheduled to start at 7 p.m. Tickets for the game are on sale now and can be purchased at the Ticket Atlantic Box Office or online.

redpajama_set_name: RedPajamaCommonCrawl


SEATTLE: The Binaytara Foundation, a cancer health nonprofit based in Washington, is hosting the 2018 Summit on National and Global Cancer Health Disparities from April 28-29 in Seattle.
The conference is designed to provide education to physicians and other healthcare professionals, and to build momentum toward ending healthcare disparities preventing disenfranchised groups from receiving the best possible care.
The highlight of the summit will be a pair of debates on the rising cost of cancer care, featuring high-profile panelists and moderators.
KIRO 7 Anchor Michelle Millman will co-moderate the debate, which will be held from 3:45 to 5 p.m. April 28 at Hilton Seattle. KOMO 4 Reporter Denise Whitaker will co-moderate the second debate the next day from 11 a.m. to noon.
Binaytara Foundation President Dr. Binay Shah said the debate sessions will promote a better understanding of factors contributing to soaring healthcare costs.
Panelists joining Congressman Smith include Cardinal Health Specialty Solutions VP and CMO Dr. Chadi Nabhan, Oregon Health and Sciences University Assistant Professor of Medicine Dr. Vinay Prasad, Leukemia and Lymphoma Society CMO Dr. Gwen Nichols, and Biotheranostics CEO Don Hardison.
The second debate will focus on ways to contain the cost of cancer care.
Panelists for the second debate include Kraft Family Professor of Medicine Dr. Kenneth Anderson, Hutchinson Institute for Cancer Outcomes Co-Director Dr. Gary Lyman, McKesson VP and CMO Dr. Michael Seiden, and CLL Society Founder Dr. Brian Koffman.
The 2018 Summit on National and Global Cancer Health Disparities is the inaugural conference of what will become an annual event. The Binaytara Foundation is also hosting the 6th International Conference on Advances in Hematology and Oncology August 4-5 in Couer d'Alene, Idaho. It is one of the largest medical education conference for oncology in the region.
The Binaytara Foundation also works on projects abroad. It will soon sign a memorandum of understanding with the Nepalese government to establish a state-of-the-art public cancer center near the city of Janakupur. It is also expanding hospice and palliative care services throughout Nepal and India.


Alberta Ferretti built her empire on the foundation of light and flowy couture. From flexible silhouettes to shinny silk, her work has remained consistent and consistently good. So she would be in no hurry to change things up. But as it is with artists they rarely follow the safest route. And this Haute Couture collection is Alberta's plunge into the unknown…into the structured silhouettes and more minimalist expressions of joy. All the other things that make her work standout still remain intact making this a collection worth savoring. Evolution always is.


Has anybody heard of malware with the name 'better srf', or close variants? I have received no relevant messages from Symantec about it. I have tried to remove it using 'Hijack This' but it cannot be touched.
That seems suspicious, especially since any online work using my browser (Firefox) is extremely slow, almost unusable. When I type I can get 4 or 5 letters ahead of myself. All other operations, like searching and loading, are also slow.
SO, my question is a dual one. What is bettersrf and could my online problems be a result of an infection by it or something else?
Re: Extremely slow browser sessions Better Srf?


text:
IPM Insights
A New Age for an Age-Old Problem
Ken Giles gave a keynote speech on engineering developments in robotics and sensors at the International IPM Symposium. Source: K. Judd, Northeastern IPM Center
Imagine: A fleet of robots maneuvers through a field in which a multitude of different plants—among them carrots, corn, and cauliflower—are growing side by side. A miniature droid equipped with sensors tenderly nurtures the crops, taking various measurements, looking for nutrient deficiencies, water stress, or an impending disease. Challenges that have plagued farmers for hundreds of years could be met with precision care, yielding healthy crops that can withstand nature's elements.
What might seem like a scene from Star Trek is indeed the direction that some growers are heading. The Northeastern IPM Center recently organized a session on this topic at the International IPM Symposium in Salt Lake City, Utah.
Experts see big opportunities in one area: how growers spray pest management materials. New machines could help farmers manage the droplet size of materials, reduce application rates, and mitigate spray drift. They could also minimize worker exposure and materials deposited on the ground. Making payloads smaller will reduce demands on farm vehicles, enable higher operating speeds, and boost productivity.
Prevention and Precision
Three objectives form the trifecta of precision IPM: efficacy of application, protection of non-targets, and productivity.
"Any successful technology has to improve one and at least be neutral on the other two," said Ken Giles, a professor of engineering at the University of California at Davis (UCD), who was one of the keynote speakers at the session.
In an orchard, a successful example of this technology turns off spray nozzles between trees. Scientists collected data that showed a 15 to 40 percent reduction in materials when they used this technology.
Today, with sensors becoming more sophisticated, machines can get a better sense of the shape of the tree, and use mechanical actuators to better reach the target.
Another example is found in a lettuce growing operation.
"Lettuce grows very quickly, so the target is always changing," said Giles. "To make matters even more difficult, only six to eight percent of the land is covered with the target crop."
He and his UCD colleague David Slaughter did sensing and applicator work that allowed them to adjust the width of spray on the target, and deployed it in a 12-row system in lettuce. The result: a 60 to 80 percent reduction in materials used, and a 90 percent reduction in soil deposition in material that should have been on the plant.
"This system is now very common in the Salinas Valley of California," said Giles.
Giles has seen some of his team's developments take 10 to 15 years to come to market. But when they do, they have spread very quickly with many vendors providing products and services.
Robots in the Sky
Giles also sees big opportunities for crop protection using unmanned aerial vehicles (UAVs). In one recent study, his UAVs sprayed only water. Then, his team applied for a Part 137 exemption that allowed them to spray an active ingredient. They were required to follow the same aviation rules that apply to crop dusting. Looked at in terms of productivity, the UAVs were fast—in fact, multiple times faster. In an area where terrain, slope, and turns meant ground vehicles could cover one acre per hour or less, UAVs were able to cover three to seven acres per hour.
This idea may not be ready for mainstream use just yet: some product labels have specific instructions that preclude UAV use, and conflicts over airspace could arise, as manned commercial crop dusters operate in the same space.
While engineering developments can take several years to get to market, these new technologies could soon meet all three objectives of precision IPM: efficacy of application, protection of non-targets, and productivity.
— by CHRIS GONZALES
The Northeastern IPM Center promotes integrated pest management for reducing risks to human health and the environment. If republishing our news, please acknowledge the source ("From Northeast IPM Insights ") along with a link to our website.
Diagnosis from the Air Could Help Farms on the Ground
October 2015 Download
Resources October 2015
On a Wing and a Prayer: Insects from the Sky to the Rescue
Moving Integrated Weed Management into the Future
2019 issues:
March July
January April July November
January April July October
E-book & PDF Editions
IPM Insights Archive


Burma B2B Marketplace is part of TradeBoss.com B2B Marketplace and it is displaying mainly companies, products and buy / sell trade leads from Burma. If you are a company from Burma or would like to do business with companies from Burma or would like your company to be listed on Burma B2B Website you are welcome to create a free account.
We are regularly Buying: agrochemical, ro water purifier, elctronics, pump, chocolate, chemical, steel, cement.
We are regularly Selling: bitumenbitumen emulsion, aluminum sulfate, cables wires, riceyellow maizesugar, thermoplastics, road safety products, lighting products, mobile phone aa emergency charger, tyre.
We are regularly Buying: bitumenbitumen emulsion, aluminum sulfate, cables wires, thermoplastics road marking powders, road safety products, lighting products.
We are regularly Selling: animal feed additives, live vaccines for animal, day old broilers, day old layers, feed concentrates, animal feed grade soy beans, apis for animals.
We are regularly Buying: veterinary biologicals, veterinary pharmaceuticals, premixes for poultry and cattle, electrolytes for animals, broiler chicken, layer chicken, soy bean for animal, kokyawminmmgmailcom.
We are regularly Selling: beans, dals, joss powder, metals, pulses, sesame seeds, spices, tamarind, turmeric finger.
We are regularly Buying: dates, pharmaceutical raw materials, plastic resins, industrial machineries, water pumps, dump trucks.


text:
"""An implementation of Common Lisp's FORMAT."""

from __future__ import with_statement

import sys
from cStringIO import StringIO
from math import log10
import re
import unicodedata
from bindings import bindings
from charpos import CharposStream
from prettyprinter import PrettyPrinter
import printervars

__all__ = ["Formatter", "format"]

class FormatError(StandardError):
    def __init__(self, control, *args):
        self.control = control
        self.args = args

    def __str__(self):
        return format(None, self.control, *self.args)

class FormatParseError(FormatError):
    offset = 2
    def __init__(self, control, index, message, *args):
        super(FormatParseError, self).__init__("~?~%~V@T\"~A\"~%~V@T^",
                                               message, args, self.offset,
                                               control, index + self.offset)

class UpAndOut(Exception):
    pass

class UpUpAndOut(Exception):
    pass

class Arguments(object):
    """A container for format arguments.  Essentially a read-only list, but
    with random-access, bi-directional iterators."""

    def __init__(self, args, outer=None):
        self.args = args
        self.outer = outer
        self.len = len(self.args)
        self.cur = 0
        self.empty = (self.len == 0)

    def __len__(self): return self.len
    def __getitem__(self, key): return self.args[key]
    def __iter__(self): return self

    def next(self):
        if self.empty:
            raise StopIteration
        arg = self.args[self.cur]
        self.cur += 1
        self.empty = (self.cur == self.len)
        return arg

    def prev(self):
        if self.cur == 0:
            raise StopIteration
        self.cur -= 1
        self.empty = False
        return self.args[self.cur]

    def peek(self, n=0):
        return self.args[self.cur + n]

    def goto(self, n):
        if n < 0 or n >= self.len:
            raise IndexError("index %d is out of bounds" % n)
        self.cur = n
        self.empty = False

    @property
    def remaining(self):
        return self.len - self.cur

class Modifiers(object):
    colon = frozenset([":"])
    atsign = frozenset(["@"])
    both = frozenset([":@"])
    all = colon | atsign | both

class Directive(object):
    """Base class for all format directives.  The control-string parser creates
    instances of (subclasses of) this class, which produce appropriately
    formatted output via their format methods."""

    variable_parameter = object()
    remaining_parameter = object()
    modifiers_allowed = None
    parameters_allowed = 0
    need_charpos = False
    need_prettyprinter = False

    def __init__(self, params, colon, atsign,
                 control="", start=0, end=0, parent=None):
        if (colon or atsign) and self.modifiers_allowed is None:
            raise FormatError("neither colon nor at-sign allowed "
                              "for this directive")
        elif (colon and atsign) and ":@" not in self.modifiers_allowed:
            raise FormatError("cannot specify both colon and at-sign")
        elif colon and ":" not in self.modifiers_allowed:
            raise FormatError("colon not allowed for this directive")
        elif atsign and "@" not in self.modifiers_allowed:
            raise FormatError("at-sign not allowed for this directive")
        if len(params) > self.parameters_allowed:
            raise FormatError("no~@[ more than ~D~] parameter~:P allowed "
                              "for this directive", self.parameters_allowed)

        self.params = params; self.colon = colon; self.atsign = atsign
        self.control = control; self.start = start; self.end = end
        self.parent = parent

    def __str__(self): return self.control[self.start:self.end]
    def __len__(self): return self.end - self.start

    def format(self, stream, args):
        """Output zero or more arguments to stream."""
        pass

    def param(self, n, args, default=None):
        if n < len(self.params):
            p = self.params[n]
            if p is Directive.variable_parameter: p = args.next()
            elif p is Directive.remaining_parameter: p = args.remaining
            return p if p is not None else default
        else:
            return default

    def governor(self, cls):
        """If an instance of cls appears anywhere in the chain of parents from
        this instance to the root, return that instance, or None otherwise."""
        parent = self.parent
        while parent:
            if isinstance(parent, cls):
                return parent
            parent = parent.parent
        return None

class DelimitedDirective(Directive):
    """Delimited directives, such as conditional expressions and
    justifications, are composed of an opening delimiter, zero or more
    clauses separated by a separator, and a closing delimiter.

    Subclasses should define a class attribute, delimiter, that specifies
    the class of the closing delimiter.  Instances will have that attribute
    set to the instance of that class actually encountered."""

    delimiter = None

    def __init__(self, *args):
        super(DelimitedDirective, self).__init__(*args)
        self.clauses = [[]]
        self.separators = []

    def append(self, x):
        if isinstance(x, Separator):
            self.separators.append(x)
            self.clauses.append([])
        elif isinstance(x, self.delimiter):
            self.delimiter = x
            self.delimited()
        else:
            self.clauses[len(self.separators)].append(x)
        self.end = x.end if isinstance(x, Directive) else (self.end + len(x))

    def delimited(self):
        """Called when the complete directive, including the delimiter, has
        been parsed."""
        self.need_prettyprinter = any([x.need_prettyprinter \
                                           for c in self.clauses \
                                           for x in c \
                                           if isinstance(x, Directive)])
        self.need_charpos = self.need_prettyprinter or \
            any([x.need_charpos \
                     for c in self.clauses \
                     for x in c \
                     if isinstance(x, Directive)])

# Basic Output

ascii_control_chars = {
    0: ("^@", "nul"),   1: ("^A", "soh"),  2: ("^B", "stx"),  3: ("^C", "etx"),
    4: ("^D", "eot"),   5: ("^E", "enq"),  6: ("^F", "ack"),  7: ("^G", "bel"),
    8: ("^H", "bs"),    9: ("\t", "ht"),  10: ("\n", "nl"),  11: ("^K", "vt"),
   12: ("^L", "np"),   13: ("^M", "cr"),  14: ("^N", "so"),  15: ("^O", "si"),
   16: ("^P", "dle"),  17: ("^Q", "dc1"), 18: ("^R", "dc2"), 19: ("^S", "dc3"),
   20: ("^T", "dc4"),  21: ("^U", "nak"), 22: ("^V", "syn"), 23: ("^W", "etb"),
   24: ("^X", "can"),  25: ("^Y", "em"),  26: ("^Z", "sub"), 27: ("^[", "esc"),
   28: ("^\\", "fs"),  29: ("^]", "gs"),  30: ("^^", "rs"),  31: ("^_", "us"),
  127: ("^?", "del")
}

python_escapes = {
    "\\": "\\", "\'": "\'", "\a": "a", "\b": "b", "\f": "f", "\n": "n",
    "\r": "r", "\t": "t", "\v": "v"
}

class Character(Directive):
    modifiers_allowed = Modifiers.all

    def format(self, stream, args):
        char = unicode(args.next())
        if len(char) != 1:
            raise TypeError("expected single character")
        if self.atsign:
            if char in python_escapes:
                stream.write('"\\%s"' % python_escapes[char])
            else:
                try:
                    stream.write('u"\\N{%s}"' % unicodedata.name(char))
                except ValueError:
                    stream.write(repr(char))
        else:
            if unicodedata.category(char).startswith("C"):
                try:
                    stream.write(unicodedata.name(char))
                except ValueError:
                    code = ord(char)
                    if code in ascii_control_chars:
                        i = 1 if self.colon else 0
                        stream.write(ascii_control_chars[code][i])
                    else:
                        raise FormatError("unprintable character")
            else:
                stream.write(char)

class ConstantChar(Directive):
    """Directives that produce strings consisting of some number of copies of
    a constant character may, if the parameter is not V or #, be optimized by
    producing the strings directly, rather than a Directive instance."""

    modifiers_allowed = None
    parameters_allowed = 1

    def __new__(cls, params, colon, atsign, *args):
        if colon or atsign:
            raise FormatError("neither colon nor at-sign allowed "
                              "for this directive")
        if not params:
            return cls.character
        elif params and isinstance(params[0], int):
            return cls.character * params[0]
        else:
            return super(ConstantChar, cls).__new__(cls, params, colon, atsign,
                                                    *args)

    def format(self, stream, args):
        stream.write(self.character * self.param(0, args, 1))

class Newline(ConstantChar):
    character = "\n"

class FreshLine(Directive):
    need_charpos = True

    def format(self, stream, args):
        n = self.param(0, args, 1)
        if n > 0:
            try:
                stream.fresh_line()
                n -= 1
                while n > 0:
                    stream.terpri()
                    n -= 1
            except AttributeError:
                stream.write("\n" * n)

class Page(ConstantChar):
    character = "\f"

class Tilde(ConstantChar):
    character = "~"

# Radix Control

digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"

def convert(n, radix):
    """Yield the digits of the non-negative integer n in the given radix."""
    def le_digits(n, radix):
        while n > 0:
            yield digits[n % radix]
            n /= radix
    if radix < 2 or radix > 36:
        raise ValueError("radix out of range")
    return reversed(tuple(le_digits(n, radix)))

roman_numerals = ["M", 2, "D", 5, "C", 2, "L", 5, "X", 2, "V", 5, "I"]

def roman_int(n, oldstyle=False):
    """Yield the Roman numeral representation of n.  This routine is a
    straightforward translation of the code from section 69 of TeX82, where
    it is prefaced by the following comment:

        Readers who like puzzles might enjoy trying to figure out how
        this tricky code works; therefore no explanation will be given.
        Notice that 1990 yields MCMXC, not MXM.

    The only substantive change to the algorithm is the addition of the
    old-style flag."""
    if n < 1 or n > (4999 if oldstyle else 3999):
        raise ValueError("integer cannot be expressed as Roman numerals")

    # j & k are mysterious indices into roman_numerals;
    # u & v are mysterious numbers
    j = 0; v = 1000
    while True:
        while n >= v:
            yield roman_numerals[j]; n -= v
        if n <= 0: return   # nonpositive input produces no output
        k = j + 2; u = v / roman_numerals[k - 1]
        if roman_numerals[k - 1] == 2:
            k += 2; u /= roman_numerals[k - 1]
        if n + u >= v and not oldstyle:
            yield roman_numerals[k]; n += u
        else:
            j += 2; v /= roman_numerals[j - 1]

# English ordinal & cardinal conversion code contributed by Richard M.
# Kreuter <kreuter@progn.net>.

cardinals = ["zero", "one", "two" , "three", "four",
             "five", "six", "seven", "eight", "nine",
             "ten", "eleven", "twelve", "thirteen", "fourteen",
             "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"]

ordinals = ["zeroth", "first", "second", "third", "fourth",
            "fifth", "sixth", "seventh", "eighth", "ninth",
            "tenth", "eleventh", "twelfth", "thirteenth", "fourteenth",
            "fifteenth", "sixteenth", "seventeenth", "eighteenth", "nineteenth"]

tenstems = ["", "ten", "twent", "thirt", "fourt", "fift",
            "sixt", "sevent", "eight", "ninet"]

ten_cubes = ["", "thousand", "million", "billion", "trillion",
             "quadrillion", "quintillion", "sextillion", "septillion",
             "octillion", "nonillion"]

def itoe(n, ordinal):
    if n < 0:
        s = "negative "
        n = abs(n)
    else:
        s = ""

    if ordinal:
        table = ordinals
        osuff = "th"
        tsuff0 = "ieth"
    else:
        table = cardinals
        osuff = ""
        tsuff0 = "y"
    tsuff1 = "y"
    if n < 1000:
        if n >= 100:
            return s + "%s hundred" % itoc(n/100) + \
                (osuff if n % 100 == 0 else (" " + itoe(n % 100, ordinal)))
        else:
            if n < 20:
                return s + table[n]
            else:
                ones = n % 10
                return s + tenstems[n/10] + \
                    (tsuff0 if ones == 0 else (tsuff1 + "-" + table[ones]))

    v = int(log10(n)) / 3
    u = 1000 ** v
    while v >= 0:
        q = n / u
        if q != 0:
            s += itoe(q, ordinal and n < 1000)
            if v >= len(ten_cubes):
                s += " times ten to the %s power plus" % (itoo(3*v))
            elif ten_cubes[v]:
                s += " " + ten_cubes[v]
            n %= u
            if n == 0:
                if v > 0: s += osuff
            else:
                if n >= 100 and v < len(ten_cubes): s += ","
                s += " "
        v -= 1
        u /= 1000
    return s

def itoo(n):
    return itoe(n, True)

def itoc(n):
    return itoe(n, False)

class Numeric(Directive):
    """Base class for numeric (radix control) directives."""

    modifiers_allowed = Modifiers.all
    parameters_allowed = 4

    def format(self, stream, args):
        def commafy(s, commachar, comma_interval):
            """Add commachars between groups of comma_interval digits."""
            first = len(s) % comma_interval
            a = [s[0:first]] if first > 0 else []
            for i in range(first, len(s), comma_interval):
                a.append(s[i:i + comma_interval])
            return commachar.join(a)

        i = 0
        if self.radix:
            radix = self.radix
        else:
            radix = int(self.param(0, args, 0)); i += 1
        mincol = int(self.param(i, args, 0)); i += 1
        padchar = str(self.param(i, args, " ")); i += 1
        commachar = str(self.param(i, args, ",")); i += 1
        comma_interval = int(self.param(i, args, 3)); i += 1

        n = args.next()
        s = self.convert(abs(n), radix)
        sign = ("+" if n >= 0 else "-") if self.atsign else \
               ("-" if n < 0 else "")
        if self.colon:
            if padchar == "0" and mincol > len(s) + len(sign):
                # We pad with zeros first so that they can be commafied,
                # too (cf. CLiki Issue FORMAT-RADIX-COMMACHAR).  But in
                # order to figure out how many to add, we need to solve a
                # little constraint problem.
                def col(n):
                    return n + (n-1)/comma_interval + len(sign)
                width = -1
                for i in range(len(s), mincol):
                    if col(i) == mincol:
                        # exact fit
                        width = i
                        break
                    elif col(i) > mincol:
                        # too big
                        width = i - 1
                        break
                assert width > 0, "couldn't find a width"
                s = s.rjust(width, padchar)

                # If we're printing a sign, and the width that we chose
                # above is a multiple of comma_interval, we'll need (at
                # most one) extra space to get up to mincol.
                padchar = " "

            s = commafy(s, commachar, comma_interval)
        with bindings(printervars,
                      print_escape=False,
                      print_radix=False,
                      print_base=radix,
                      print_readably=False):
            stream.write((sign + s).rjust(mincol, padchar))

class Radix(Numeric):
    parameters_allowed = 5
    radix = None

    def __init__(self, *args):
        super(Radix, self).__init__(*args)
        if not self.params:
            self.format = self.old_roman if self.colon and self.atsign \
                                         else self.roman if self.atsign \
                                         else self.ordinal if self.colon \
                                         else self.cardinal

    def convert(self, n, radix):
        return "".join(convert(n, radix))

    def roman(self, stream, args):
        stream.write("".join(roman_int(args.next())))

    def old_roman(self, stream, args):
        stream.write("".join(roman_int(args.next(), True)))

    def ordinal(self, stream, args):
        stream.write(itoo(args.next()))

    def cardinal(self, stream, args):
        stream.write(itoc(args.next()))

class Decimal(Numeric):
    radix = 10
    def convert(self, n, radix):
        return "%d" % n

octal_digits = ["000", "001", "010", "011", "100", "101", "110", "111"]

class Binary(Numeric):
    radix = 2
    def convert(self, n, radix):
        return "".join(octal_digits[int(digit)] \
                           for digit in "%o" % n).lstrip("0")

class Octal(Numeric):
    radix = 8
    def convert(self, n, radix):
        return "%o" % n

class Hexadecimal(Numeric):
    radix = 16
    def convert(self, n, radix):
        return "%X" % n

# Printer Operations

class Padded(Directive):
    modifiers_allowed = Modifiers.all
    parameters_allowed = 4
    need_prettyprinter = True

    def format(self, stream, args):
        def pad(s):
            mincol = self.param(0, args, 0)
            colinc = self.param(1, args, 1)
            minpad = self.param(2, args, 0)
            padchar = self.param(3, args, " ")

            # The string methods l/rjust don't support a colinc or minpad.
            if colinc != 1: raise FormatError("colinc parameter must be 1")
            if minpad != 0: raise FormatError("minpad parameter must be 0")

            return s.rjust(mincol, padchar) if self.atsign else \
                   s.ljust(mincol, padchar)

        arg = args.next()
        stream.pprint("[]" if self.colon and arg is None \
                           else pad(format(None, "~W", arg)) if self.params \
                           else arg)

class Aesthetic(Padded):
    def format(self, stream, args):
        with bindings(printervars, print_escape=None):
            super(Aesthetic, self).format(stream, args)

class Standard(Padded):
    def format(self, stream, args):
        with bindings(printervars, print_escape=True):
            super(Standard, self).format(stream, args)

class Write(Directive):
    modifiers_allowed = Modifiers.all
    need_prettyprinter = True

    def __init__(self, *args):
        super(Write, self).__init__(*args)
        if self.colon or self.atsign:
            self.bindings = {}
            if self.colon:
                self.bindings["print_pretty"] = True
            if self.atsign:
                self.bindings["print_level"] = None
                self.bindings["print_length"] = None
            self.format = self.format_with_bindings

    def format(self, stream, args):
        stream.pprint(args.next())

    def format_with_bindings(self, stream, args):
        with bindings(printervars, **self.bindings):
            stream.pprint(args.next())

# Pretty Printer Operations

class ConditionalNewline(Directive):
    modifiers_allowed = Modifiers.all
    need_prettyprinter = True

    def format(self, stream, args):
        stream.newline(mandatory=(self.colon and self.atsign), fill=self.colon)

def fill_paragraph(body, blanks=re.compile(r"(\s+)")):
    """Insert a ~:_ after each group of blanks immediately contained in the
    body.  This makes it easy to achieve the equivalent of paragraph filling."""
    for x in body:
        if isinstance(x, basestring):
            for (i, s) in enumerate(blanks.split(x)):
                if i % 2 == 0:
                    if s: yield s
                else:
                    yield s
                    yield ConditionalNewline([], True, False)
        else:
            yield x

class LogicalBlock(DelimitedDirective):
    # Note: instances of this class are never created directly; the
    # delimiter method of the Justification class changes the class
    # of instances delimited with "~:>".

    need_prettyprinter = True

    def delimited(self):
        super(LogicalBlock, self).delimited()

        # Note: with the colon modifier, the prefix & suffix default to
        # square, not round brackets; this is Python, not Lisp.
        self.prefix = "[" if self.colon else ""
        self.suffix = "]" if self.colon else ""
        if len(self.clauses) == 0:
            self.body = []
        elif len(self.clauses) == 1:
            (self.body,) = self.clauses
        elif len(self.clauses) == 2:
            ((self.prefix,), self.body) = self.clauses
        elif len(self.clauses) == 3:
            ((self.prefix,), self.body, (self.suffix,)) = self.clauses
        else:
            raise FormatError("too many segments for ~~<...~~:>")
        self.per_line = self.separators and self.separators[0].atsign

        if self.delimiter.atsign:
            self.body = fill_paragraph(self.body)

    def format(self, stream, args):
        with stream.logical_block(None,
                                  prefix=str(self.prefix),
                                  per_line=self.per_line,
                                  suffix=str(self.suffix)):
            try:
                apply_directives(stream,
                                 self.body,
                                 args if self.atsign \
                                      else Arguments(args.next()))
            except UpAndOut:
                pass

class Indentation(Directive):
    modifiers_allowed = Modifiers.colon
    parameters_allowed = 1
    need_prettyprinter = True

    def format(self, stream, args):
        stream.indent(offset=int(self.param(0, args, 0)), relative=self.colon)

# Layout Control

class Tabulate(Directive):
    modifiers_allowed = Modifiers.all
    parameters_allowed = 2
    need_charpos = True

    def format(self, stream, args):
        def ceiling(a, b):
            q, r = divmod(a, b)
            return (q + 1) if r else q

        def output_spaces(stream, n):
            stream.write(" " * n)

        if self.colon:
            raise FormatError("~A not yet supported", self)
        elif self.atsign:
            # relative tabulation
            colrel = int(self.param(0, args, 1))
            colinc = int(self.param(1, args, 1))
            try:
                cur = stream.charpos
                output_spaces(stream,
                              colinc * ceiling(cur + colrel, colinc) - cur)
            except AttributeError:
                output_spaces(stream, colrel)

        else:
            # absolute tabulation
            colnum = int(self.param(0, args, 1))
            colinc = int(self.param(1, args, 1))
            try:
                cur = stream.charpos
                if cur < colnum:
                    output_spaces(stream, colnum - cur)
                elif colinc > 0:
                    output_spaces(stream, colinc - ((cur - colnum) % colinc))
            except AttributeError:
                stream.write("  ")

class EndJustification(Directive):
    modifiers_allowed = Modifiers.all

class Justification(DelimitedDirective):
    modifiers_allowed = Modifiers.all
    delimiter = EndJustification

    def delimited(self):
        if self.delimiter.colon:
            # Blame Dick Waters.
            self.__class__ = LogicalBlock
            self.delimited()
        else:
            super(Justification, self).delimited()

    def format(self, stream, args):
        raise FormatError("justification not yet supported")

# Control-Flow Operations

class GoTo(Directive):
    modifiers_allowed = Modifiers.all
    parameters_allowed = 1

    def format(self, stream, args):
        if self.atsign:
            args.goto(self.param(0, args, 0))
        else:
            ignore = args.prev if self.colon else args.next
            for i in range(self.param(0, args, 1)):
                ignore()

class EndConditional(Directive):
    pass

class Conditional(DelimitedDirective):
    modifiers_allowed = Modifiers.all
    parameters_allowed = 1
    delimiter = EndConditional

    def delimited(self):
        super(Conditional, self).delimited()

        if self.colon:
            if len(self.clauses) != 2:
                raise FormatError("must specify exactly two sections")
        elif self.atsign:
            if len(self.clauses) != 1:
                raise FormatError("can only specify one section")
        else:
            if len(self.separators) > 1 and \
                    any([s.colon for s in self.separators[0:-1]]):
                raise FormatError("only the last ~~; may have a colon")

    def format(self, stream, args):
        if self.colon:
            # "~:[ALTERNATIVE~;CONSEQUENT~] selects the ALTERNATIVE control
            # string if arg is false, and selects the CONSEQUENT control
            # string otherwise."
            apply_directives(stream, self.clauses[1 if args.next() else 0], args)
        elif self.atsign:
            # "~@[CONSEQUENT~] tests the argument.  If it is true, then
            # the argument is not used up by the ~[ command but remains
            # as the next one to be processed, and the one clause
            # CONSEQUENT is processed.  If the arg is false, then the
            # argument is used up, and the clause is not processed."
            if args.peek():
                apply_directives(stream, self.clauses[0], args)
            else:
                args.next()
        else:
            try:
                n = self.param(0, args)
                if n is None: n = args.next()
                apply_directives(stream, self.clauses[n], args)
            except IndexError:
                if self.separators[-1].colon:
                    # "If the last ~; used to separate clauses is ~:;
                    # instead, then the last clause is an 'else' clause
                    # that is performed if no other clause is selected."
                    apply_directives(stream, self.clauses[-1], args)

class EndIteration(Directive):
    modifiers_allowed = Modifiers.colon

class Iteration(DelimitedDirective):
    modifiers_allowed = Modifiers.all
    parameters_allowed = 1
    delimiter = EndIteration

    def append(self, x):
        if isinstance(x, Separator):
            raise FormatError("~~; not permitted in ~~{...~~}")
        super(Iteration, self).append(x)

    def delimited(self):
        body = self.clauses[0]
        self.need_prettyprinter = not body or \
            any([x.need_prettyprinter for x in body if isinstance(x, Directive)])
        self.need_charpos = self.need_prettyprinter or \
            any([x.need_charpos for x in body if isinstance(x, Directive)])
        self.prepared = body and prepare_directives(body)

    def format(self, stream, args):
        max = self.param(0, args, -1)
        body = self.prepared or \
            prepare_directives(parse_control_string(args.next()))

        args = args if self.atsign else Arguments(args.next())
        next = (lambda args: Arguments(args.next(), args)) if self.colon \
                                                           else None
        write = stream.write
        i = 0
        while not args.empty or (i == 0 and self.delimiter.colon):
            if i == max: break
            i += 1
            try:
                iargs = next(args) if next else args
                fast_apply_directives(stream, write, body, iargs)
            except UpAndOut:
                continue
            except UpUpAndOut:
                break

class Recursive(Directive):
    modifiers_allowed = Modifiers.atsign
    need_charpos = True
    need_prettyprinter = True

    def format(self, stream, args):
        apply_directives(stream,
                         parse_control_string(args.next()),
                         args if self.atsign else Arguments(args.next()))

# Miscellaneous Operations

class EndCaseConversion(Directive):
    pass

class CaseConversion(DelimitedDirective):
    modifiers_allowed = Modifiers.all
    delimiter = EndCaseConversion

    def delimited(self):
        super(CaseConversion, self).delimited()
        self.body = self.clauses[0]

    def format(self, stream, args):
        stringstream = StringIO()
        try:
            Formatter(self.body)(stringstream, args)
            s = stringstream.getvalue()
        finally:
            stringstream.close()

        stream.write(s.upper() if self.colon and self.atsign \
                               else s.title() if self.colon \
                               else s.capitalize() if self.atsign \
                               else s.lower())

class Plural(Directive):
    modifiers_allowed = Modifiers.all

    def __init__(self, *args):
        def prev(args): return args.peek(-1)
        def next(args): return args.next()
        def y(arg): return "y" if arg == 1 else "ies"
        def s(arg): return "" if arg == 1 else "s"

        super(Plural, self).__init__(*args)
        self.arg = prev if self.colon else next
        self.suffix = y if self.atsign else s

    def format(self, stream, args):
        stream.write(self.suffix(self.arg(args)))

# Miscellaneous Pseudo-Operations

class Separator(Directive):
    modifiers_allowed = Modifiers.colon | Modifiers.atsign

class Escape(Directive):
    modifiers_allowed = Modifiers.colon
    parameters_allowed = 3

    def __init__(self, *args):
        super(Escape, self).__init__(*args)

        if self.colon:
            iteration = self.governor(Iteration)
            if not (iteration and iteration.colon):
                raise FormatError("can't have ~~:^ outside of a "
                                  "~~:{...~~} construct")
        self.exception = UpUpAndOut if self.colon else UpAndOut

        if len(self.params) == 0:
            self.format = self.check_remaining_outer if self.colon \
                                                     else self.check_remaining
        else:
            self.format = self.check_params

    def check_remaining(self, stream, args):
        if args.empty:
            raise UpAndOut()

    def check_remaining_outer(self, stream, args):
        if args.outer.empty:
            raise UpUpAndOut()

    def check_params(self, stream, args):
        # This could be split up, too.
        (param1, param2, param3) = (self.param(i, args) for i in range(3))
        if (param3 is not None and param1 <= param2 and param2 <= param3) or \
           (param2 is not None and param1 == param2) or \
           (param1 is not None and param1 == 0):
            raise self.exception()

format_directives = dict()

def register_directive(char, cls):
    assert len(char) == 1, "only single-character directives allowed"
    assert issubclass(cls, Directive), "invalid format directive class"
    format_directives[char.upper()] = format_directives[char.lower()] = cls

map(lambda x: register_directive(*x), {
    "C": Character, "%": Newline, "&": FreshLine, "|": Page, "~": Tilde,
    "R": Radix, "D": Decimal, "B": Binary, "O": Octal, "X": Hexadecimal,
    "A": Aesthetic, "S": Standard, "W": Write,
    "_": ConditionalNewline, "I": Indentation,
    "T": Tabulate, "<": Justification, ">": EndJustification,
    "*": GoTo, "[": Conditional, "]": EndConditional,
    "{": Iteration, "}": EndIteration, "?": Recursive,
    "(": CaseConversion, ")": EndCaseConversion, "P": Plural,
     ";": Separator, "^": Escape,
}.items())

def parse_control_string(control, start=0, parent=None):
    """Yield a list of strings and Directive instances corresponding to the
    given control string."""

    assert isinstance(control, basestring), "control string must be a string"
    assert start >= 0, "can't start parsing from end"

    i = start
    end = len(control)
    while i < end:
        tilde = control.find("~", i)
        if tilde == -1:
            yield control[i:end]
            break
        elif tilde > i:
            yield control[i:tilde]
        i = tilde + 1

        params = []
        while i < end:
            # empty parameter
            if control[i] == ",":
                params.append(None)
                i += 1
                continue

            # numeric parameter
            mark = i
            if control[i] in "+-":
                i += 1
            while i < end and control[i].isdigit():
                i += 1
            if i > mark:
                params.append(int(control[mark:i]))
                if control[i] == ",":
                    i += 1
                continue

            # character parameter
            if control[i] == "'":
                params.append(control[i+1])
                i += 2
                if control[i] == ",":
                    i += 1
                continue

            # "variable" parameter
            if control[i] in "Vv":
                params.append(Directive.variable_parameter)
                i += 1
                if control[i] == ",":
                    i += 1
                continue

            # "remaining" parameter
            if control[i] == "#":
                params.append(Directive.remaining_parameter)
                i += 1
                if control[i] == ",":
                    i += 1
                continue
            break

        colon = atsign = False
        while i < end:
            if control[i] == ":":
                i += 1
                if colon:
                    raise FormatParseError(control, i, "too many colons")
                colon = True
            elif control[i] == "@":
                i += 1
                if atsign:
                    raise FormatParseError(control, i, "too many at-signs")
                atsign = True
            else:
                break

        char = control[i]
        i += 1
        try:
            d = format_directives[char](params, colon, atsign,
                                        control, tilde, i, parent)
        except FormatError, e:
            raise FormatParseError(control, i, e.control, *e.args)
        except KeyError:
            raise FormatParseError(control, i, "unknown format directive")
        if isinstance(d, DelimitedDirective):
            for x in parse_control_string(control, i, d):
                try:
                    d.append(x)
                except FormatError, e:
                    if isinstance(x, Directive) and x is not d.delimiter:
                        i += x.start
                    raise FormatParseError(control, i, e.control, *e.args)
            i = d.end
        yield d
        if parent and d is parent.delimiter:
            return

class Formatter(object):
    def __init__(self, control):
        if isinstance(control, basestring):
            self.directives = tuple(parse_control_string(control))
        elif isinstance(control, (tuple, list)):
            self.directives = control
        self.need_prettyprinter = any([x.need_prettyprinter \
                                           for x in self.directives \
                                           if isinstance(x, Directive)])
        self.need_charpos = self.need_prettyprinter or \
            any([x.need_charpos \
                     for x in self.directives \
                     if isinstance(x, Directive)])

    def __call__(self, stream, *args):
        if not isinstance(stream, PrettyPrinter) and self.need_prettyprinter:
            stream = PrettyPrinter(stream)
        elif not isinstance(stream, CharposStream) and self.need_charpos:
            stream = CharposStream(stream)
        if len(args) == 1 and isinstance(args[0], Arguments):
            args = args[0]
        else:
            args = Arguments(args)
        apply_directives(stream, self.directives, args)
        return args

def prepare_directives(directives):
    return [(x, True) if isinstance(x, basestring) else (x.format, False) \
                for x in directives]

def fast_apply_directives(stream, write, directives, args):
    """Apply a list of prepared directives."""
    for (x, string) in directives:
        if string:
            write(x)
        else:
            x(stream, args)

def apply_directives(stream, directives, args):
    write = stream.write
    for x in directives:
        if isinstance(x, basestring):
            write(x)
        else:
            x.format(stream, args)

def format(destination, control, *args):
    if destination is None:
        stream = StringIO()
    elif destination is True:
        stream = sys.stdout
    else:
        stream = destination
    f = control if isinstance(control, Formatter) else Formatter(control)
    try:
        f(stream, *args)
    except UpAndOut:
        pass
    if destination is None:
        str = stream.getvalue()
        stream.close()
        return str


WindReach Bermuda hosted their Walk and Roll fundraising event this morning [March 24] at their Warwick location off of Spice Hill Road.
Today's event helps to raise funds in support of WindReach and marks the 18th Annual Walk & Roll held as WindReach celebrates their 20th Anniversary. The route started and ended at WindReach, with a loop through the property and the Railway Trail and allowed participants to take part in either a 2.5k or a 5k distance.


text:
Q: How can I make a variable inside a function global? I currently have the following function called saveRun()
func saveRun() {

    let startLoc = locations[0]
    let endLoc = locations[locations.count - 1]
    let startLat = startLoc.coordinate.latitude
    let startLong =  startLoc.coordinate.longitude
    let endLat = endLoc.coordinate.latitude
    let endLong = endLoc.coordinate.longitude

    //1. Create the alert controller
    let alert = UIAlertController(title: "Save the Run", message: "Choose a name: ", preferredStyle: .alert)

    //2. Add the text field
    alert.addTextField { (textField) in
        textField.text = ""
    }

    // 3. Grab the value from the text field, and print it when the user clicks OK
    alert.addAction(UIAlertAction(title: "OK", style: .default, handler: { [weak alert] (_) in
        let textField = alert?.textFields![0] // Force unwrapping because we know it exists.

        // Create name for run
        let runName = textField?.text
        let run = self.databaseRef.child(runName!)
        let user = FIRAuth.auth()?.currentUser?.uid

        // Enter run info into db
        run.child("startLat").setValue(startLat)
        run.child("startLong").setValue(startLong)
        run.child("endLat").setValue(endLat)
        run.child("endLong").setValue(endLong)
        run.child("distance").setValue(self.distance)
        run.child("time").setValue(self.seconds)
        run.child("user").setValue(user)

        // Enter locations into db

        var i = 0
        for location in self.locations {

            run.child("locations").child("\(i)").child("lat").setValue(location.coordinate.latitude)
            run.child("locations").child("\(i)").child("long").setValue(location.coordinate.longitude)
            i = i + 1

        self.performSegue(withIdentifier: DetailSegueName, sender: nil)

        }

    }))

    // 4. Present the alert
    self.present(alert, animated: true, completion: nil)

}

My problem is that I am trying to extract 'runName' from the action that I am adding when the user clicks 'Ok' on the alert controller and using it in the following function:
override func prepare(for segue: UIStoryboardSegue, sender: Any?) {
    if let detailViewController = segue.destination as? DetailViewController {
        detailViewController.runName = self.runName
    }
}

When I try to print 'runName' in DetailViewController, the value of runName is nil. The issue I think is that I cannot set a global variable inside the action I have added as it is in a function. Is there any other way I can obtain this variable's value and use it outside of the function?

A: Class YourClassName:UIViewController {

  var  runName:String = "" // This will be global for your class

  //Remove local decalration of runName variable
  func saveRun() { // your function

    alert.addAction(

      //.....
      self.runName = textfield?.text
    )

  }

}

Now you can use in whole class.

A: I solved this thanks to @DSDharma pointing out that even if 'runName' was set as a global variable, using it as a global variable inside of an alert function block required the 'self' keyword.
For example, before I had the following inside of the alert function block:
let runName = textField?.text

This needed to be changed to:
self.runName = textField?.text

redpajama_set_name: RedPajamaStackExchange


The Brothers Quay, Stephen and Timothy Quay, are identical twins and directors that have set new standards and parameters for model animation. The Quays are renowned for their craftsmanlike methods and their unusual sources of inspiration, incorporating elements from the surrealist work of the great Czech animator Jan Svankmajer and the literary sensibilities of Eastern Europe, while remaining outside any recognisable tradition. This collection features 13 films from 1979-2003.


Tuberculosis (TB) is an acute infectious disease that damages the lungs. It can be easily treated with the help of antibiotics, provided an early and accurate diagnosis is made. Diagnosis of tuberculosis can be done based on the X-ray images of the chest region. However, analyzing these X-ray films can only be done by an expert radiologist. Unfortunately, most places where tuberculosis is highly prevalent, viz. remote areas of developing and underdeveloped countries, lack skilled professional radiologists.
A team of researchers led by Baskaran Sundaram and Paras Lakhani from Thomas Jefferson University Hospital (TJUH), Philadelphia, has developed a highly innovative artificial intelligence model that can evaluate chest X-ray images to diagnose TB. The model can operate without the supervision of a radiologist, according to a EurekAlert public release.
Exemplary application of AI in healthcare artificial intelligence models is designed to accomplish complicated tasks without human interference. It functions by identifying discrepancies in the radiographs by comparing it to the database of already existing data. The researchers used this concept to train the computer systems to identify the changes in the radiographs of tuberculosis patients and healthy individuals.
According to Financial Express, Sundaram and his team used 1,007 X-ray images that included both TB and non-TB patients, for training the models. These images were obtained from the X-ray data sets of National Institutes of Health, TJUH and Belarus Tuberculosis Portal.
AlexNet and GoogLeNet were used for the development of the said artificial intelligence model. Once the training is completed, the models were used to screen 150 more X-ray images that were not included in the training.
Diagnosis was made based on the consensus decision of both the artificial intelligence models. Out of the 150 X-ray images tested, correct diagnosis was made in 137 cases (96 percent). A consensus could not be achieved in the remaining 13 images. Those cases were then recommended for expert analysis by a radiologist.
HealthDay reported the study findings that were published yesterday in the Radiology journal indicate that these models function with high accuracy. This makes them ideal for application in real time conditions. This novel application of artificial intelligence in healthcare can not only help in making fast and correct diagnosis of tuberculosis but also help in starting the treatment procedure at the earliest.


3/34 George Street would make an ideal investment only 900m to the local shopping village, medical facilities, schools and childcare, 2km to the new Maitland Hospital construction site and 2.3km to Stockland Greenhills Shopping Centre.
Comprising of 2 bedrooms both with built in robes. The functional kitchen overlooks the open plan living and dining area which offers and absolute abundance of space and versatility to create a living environment that suits your needs.
Other key features include, split system air conditioning, ceiling fans, gas connections, good size bathroom with separate toilet, internal laundry, single garage with internal access and a fenced courtyard space.
Dear Aimee, I am interested in 3/34 George St, East Maitland, NSW 2323, Listing Number 2911742 which I found on http://barclayproperty.com.au.


Microsoft Taiwan held a joint press conference with Digital China and HighCool companies at Le Meridien Hotel in Taipei June 28th to announce a "tripartite blockchain strategy cooperation" agreement has been struck between the three firms to create a vast, blockchain-moderated public-private computing cloud.
Also present at the conference were, "Taiwan's blockchain venture pioneer Hu Day…" and Zhao Zhizhong, Head of Artificial Intelligence at Microsoft Greater China.
According to the corresponding press release, the three companies hope that by combining Microsoft's Azure cloud-computing and commercial blockchain services with Digital China's commercial blockchain services and HighCool's expertise in cloud management, the resulting collaborative "super cloud" will one day be able to host the Internet of Things (IoT).
Digital China is a large, Beijing-based IT firm with the stated mission of "building a 'Digitalized China.'" It is a spin off of Lenovo, the world's second largest manufacturer of personal computers. Lenovo has had a relationship with Microsoft since the late 90's.
The release states that he three companies see a rising "demand" for the fruits of their collaboration and also quotes conclusions from the International Data Corporation, which expects enterprise blockchain spending to double in 2018, from $945 million spent last year to $2.1 billion spent this year. "Banks, logistics, and manufacturing will be the main drivers, with the financial sector investing more than $754 million in blockchain solutions," claims the Taiwanese release.
A number of blockchain consultants in the west, however, including Jimmy Song and Johnny Dilley, have openly and persistently questioned whether enterprises really need full blockchains to solve their data security, storage and distribution problems.
The problem lies in inefficiencies wrought by true blockchains, where all data must be settled, by consensus, across all the computers in a network, rather than just one or a few computers in a single database.
Secure cryptographic consensus, they say, is energy-intensive, expensive and slow.
This method of data encryption is quite strong provided that the network is decentralized. But as soon as the network is governed by a central party, the "data sanctity" created by a blockchain network can be overcome.
Therefore, critics say, there is no need for an expensive and slow blockchain in private enterprise, and such businesses should rather be using simpler forms of public key cryptography.
Possibly, firms selling "blockchain technology" today are in fact are selling "distributed ledgers" (DLTs) but aren't bothering to drop the trendy buzzword.
It is also possible that they are using smaller, trusted distributed encrypting networks rather than "trustless" autonomous networks. A small, consensus-encrypted network would, arguably, be more secure than mere password-protected data.
While small firms already contracting out their data storage to trusted brands may be happy with their services, it behooves one, especially, "on the day of the birth of the public cloud," to understand, as much as possible, exactly how one's data is being store.
Bitcoin explainer and former digital security consultant Andreas Antonopoulos has pointed out that IoT enthusiasts hope to connect people's fridges and kitchens and home security systems and heating and cooling systems, not to mention civic and national infrastructure systems, to the Internet.
For the time being, Antonopoulos says, this simply means exponentially more personal systems vulnerable to hacks.
This entry was posted in Asia, Blockchain & Digital Currency and tagged andreas antonopoulos, china, highcool, hu day, microsfot, microsoft, sun jikang, sun kong shan tao, taiwan, wu jiefu, zhao zhizhong. Bookmark the permalink.


text:
Q: Can anyone point me to information about ShapeRange().PlaceholderFormat.Position I try to address a certain placeholder on a slide (but I have 3 body placeholders - so I try to identify them). While searching for other ways than using the positions I found the property PlaceholderFormat.Position which seems to have 0 for the Title and 1 for the Subtitle - but numbers from 10, 14, 15 for the others -- seems random to me. I can't find any information about that field.
I looked here:
enter link description here

A: The .Position property doesn't look especially helpful. It just shows the stacking or Z order of the placeholder, which you can ascertain by looking at the Selection Pane (Home>Select>Selection Pane). It also doesn't exist in PowerPoint 2010 and earlier, which could be an issue of your macro is to run on other computers.
The page you linked to shows the use of .PlaceholderFormat.Type. I would think that will be more useful to tell what kind of placeholder you are working on. Here is Microsoft's enumeration page for the .Type property: PpPlaceholderType enumeration (PowerPoint)


Walker Kessler, the 6-foot-10 center from Woodward Academy (GA), spoke with ZAGSBLOG Sunday about his upcoming official visit to Duke (Feb. 1).
Kessler has previously taken official visits to Vanderbilt (Sept. 21), Michigan (Nov. 2), and most recently Virginia (Jan. 4).
"They just said pretty much, 'Hey if you come here, you're going to be our guy. We're going to run our offense around you.' Similar to how they did with Luke Kornet.
Kessler currently holds offers from schools such as Duke, Michigan, Vanderbilt, Virginia, Auburn, Georgia, UCLA, Clemson, Creighton, Florida, Florida State, Georgia Tech, Illinois, Memphis, Ole Miss, Stanford, Tennessee, Texas A&M, Wake Forest, and Xavier, among others.
According to 247Sports, Kessler is ranked as the No. 15 overall player in the Class of 2020 and the No. 2 player from the state of Georgia.


text:
<?php

namespace CL\Slack\Payload;

/**
 * @author Travis Raup <info@travisraup.com>
 */
class RtmStartPayloadResponse extends AbstractPayloadResponse
{
    /**
     * @var string
     */
    private $url;

	/**
     * @return string
     */
    public function getUrl()
    {
        return $this->url;
    }
}


text:
using System;

#if (CONFIGURATION_DEP)
using System.Configuration.Provider;
#endif

namespace System.Configuration
{
	public abstract class SettingsProvider
#if (CONFIGURATION_DEP)
		: ProviderBase
#endif
	{
		protected SettingsProvider ()
		{
		}

		public abstract SettingsPropertyValueCollection GetPropertyValues (SettingsContext context,
										   SettingsPropertyCollection collection);

		public abstract void SetPropertyValues (SettingsContext context,
							SettingsPropertyValueCollection collection);

		public abstract string ApplicationName { get; set; }
	}

}


Tara Marie is a writer for a bunch of different places, but no comic book companies, sadly. If she's not writing, she's watching horror movies or The Good Wife. You can contact her by screaming into the night on a full moon.


We hope that you have enjoyed your stay with us. We greatly appreciate your time taken to let us know your comments so we can continually serve you better. Is there something you particularly liked or a service you felt could be improved? Simply fill up the form below and click on the Submit button at the bottom of the page to let us know. Please note that your name and comments may be featured on our website for viewers' reading pleasure.


text:
Elite Jockeying in Libya's Transition
By Tarek Megerisi
Ghassan Salamé's action plan for Libya faces numerous obstacles from entrenched political elites, who see it as just another venue in which to seek personal gain.
On February 14, Libya's Supreme Court rejected a ruling by the Bayda court of appeals against the Constitutional Drafting Assembly's (CDA) July 2017 vote to approve a draft constitution, which ended up stuck in legal limbo.
The Supreme Court's decision thereby paves the way for a constitutional referendum and future parliamentary and presidential elections.
This appears to advance the action plan that UN Special Representative to Libya Ghassan Salamé announced in September 2017, the product of two months of consultation with various Libyan and international stakeholders.
He was adamant that the plan was the product of Libyan ideas and aspirations to resolve the unpredictability and inherent instability of the country's prolonged transitional period.
This distinguished him from his predecessors and allowed him, as well as the UN Support Mission in Libya (UNSMIL), to move away from the open-ended policy of promoting unity talks, which had not made any meaningful progress since they began in 2014.
Yet this plan faces numerous obstacles, particularly from entrenched political elites who see Salame's action plan as just another venue in which to seek personal gain.
The action-plan itself was presented, perhaps optimistically, as a clear path toward a constitutional state. First the Libyan Political Agreement (LPA) that provides the legal framework for the current political landscape would be amended based on agreements between the Tobruk-based House of Representatives (HoR)—the internationally recognized elected legislature—and the Tripoli-based High Council of State (HCS), a consultative body.
This would facilitate a functioning executive branch that could both stabilize the country by confronting some of the more immediate crises and implement the rest of the action plan.
This would be followed by a national conference bringing together Libyan stakeholders from across the political spectrum in order to unify Libya's political, economic, and security actors behind the legal changes and minimize the chances that they choose to play spoilers. Only after the conference would the HoR then focus on drafting the electoral laws to hold a constitutional referendum and new presidential and parliamentary elections.
While most Libyans agree with Salamé that Libya's crises require solutions from Libyans, he underestimated the difficulty of getting political figures to implement these solutions.
Troublingly, Libyan and international actors alike are increasingly focusing on the eventual elections as a means of bypassing these obstacles—an approach that risks mimicking the Government of National Accord (GNA), which was rushed into place before being fully agreed on.
As such, the HoR objected to it and never ratified it, and the GNA spent two years as an ineffectual executive branch that many Libyans rejected as a UN imposition.
Although the technical components of Salamé's approach to Libya were sound, the action plan most notably failed to understand the political status quo that has blocked substantive progress for six years.
Political elites see the transition itself as a zero-sum competition that offers complete control over Libya.
They maintain power by controlling territory and resources, which brings international legitimacy and the ability to buy the loyalty of local communities. Yet these dominant political actors have little effective national leadership, given they operate in ever smaller circles and have dwindling direct influence with the population.
Moreover, they have no reason to enact Salamé's action plan, which seeks to end the very status quo in which they are invested, instead cynically using it as a vehicle to raise their own status.
This simplistic realpolitik is evident in the attempts to approve constitutional amendments, for example. Salamé tried to expedite the LPA negotiations by offering up pre-drafted amendments—based on informal agreements reached in previous negotiations—to be approved by the HoR and HCS.
These amendments included shrinking the size of the unwieldy Presidency Council from nine to three members and putting military institutions under the Presidency Council's civilian oversight.
Meanwhile the HoR, which had been increasingly marginalized, would become the legislature of a fully functioning political system, with powers of executive oversight.
Agila Saleh, president of the HoR, swiftly organized a vote on November 21 approving these amendments, overcoming the institution's usual problems of reaching quorum by chartering a flight to bring parliamentarians to and from Tobruk just for the vote.
However, the HCS, and more specifically its president, Abdurrahman al-Swehli, blocked the progression of these amendments on November 24, releasing a statement rejecting the proposal against the wishes of the rest of HCS in a cynical attempt to leverage the situation for personal gain.
He demanded that the HCS share equal powers with the HoR as a prerequisite for approving them, and introduced new, tangential demands such as that Libya end Egypt's involvement in parallel military unification talks. Moreover, in September he tried to launch his own transition initiative separate from Salamé's action plan and on December 27 announced the HCS had approved a constitutional referendum law.
Although such a law is beyond the purview of the HCS, it is intended to redirect the conversation away from the stalled LPA amendments and toward future elections.
Swelhi's push to put together a constitutional referendum law also allows the HCS to one-up the HoR, which has been obstructing the process of finalizing a new constitution.
Agila Saleh, fearing that elections within a constitutional Libya would limit his power as president of the HoR, has long opposed the Constitutional Drafting Assembly (CDA), itself a key component in the action plan's success.
When the CDA approved a draft constitution in July 2017, the HoR was supposed to pass a referendum law within 30 days. However, on August 16 the Bayda appeals court invalidated the CDA's vote to approve the draft on procedural grounds.
After the CDA challenged this ruling, on February 14 the Tripoli-based Supreme Court overturned it, claiming that an administrative court does not have the jurisdiction to rule on matters involving the CDA. Although the CDA has managed to have its vote recognized, it could still find itself directly challenged in the Supreme Court.
Moreover, Saleh has the capacity to obstruct the progress of the constitution, as he demonstrated on February 20, when eighteen parliamentarians from eastern Libya released a statement claiming that they do not consider the Supreme Court's ruling valid and they will refuse to issue a referendum law.
While some political actors stymie the technical steps of Salamé's action plan, others attempt to pervert the end product. Field Marshal Khalifa Haftar is attempting to both expedite and control upcoming presidential elections.
Although he remains outside Libya's transitional political structure, he has forced himself into relevance over the past three years by taking military control over most of eastern Libya and the majority of Libya's oil terminals. However, he can neither conquer the rest of the country nor maintain his control over the factions which comprise his "Libyan National Army," so he agreed to the concept of elections as a means to advance from military leader to president, as Egypt's Abdel Fattah el-Sisi did.
Since then, he has tried to take control over the electoral process, repeatedly accusing the High National Elections Commission of being "infested" by the Muslim Brotherhood and demanding they relocate to the eastern city of Tobruk. In a televised speech on December 17, he claimed that the LPA's mandate had expired and that therefore his self-proclaimed Libyan National Army was the only remaining legitimate institution.
Attempting to avoid the civilian oversight and constitutional limitations the action plan would likely bring, he claimed that he would no longer listen to the international community, only to the Libyan people.
As these ruses failed to bring the institutions planning and overseeing the elections under his control, he ominously claimed in a February interview with Jeune Afrique that he would be forced to seize full military control of the country if elections failed to bring a satisfactory solution.
With the action plan stalling on all fronts, Salamé is being confronted with the reality that he will need to change his approach to succeed in Libya. The support of the international community could give him the time and resources to envision a way to counter the vested interests blocking reform.
This could entail, for example, finding new interlocutors who can effect change, for although the current politicians have nominal power, their influence, legal mandates, and institutional control are weak.
By pursuing local reconciliation and preparing an executive action plan to stabilize the economy they can provide something for Libyans to rally around and begin reducing the value of the status quo for many of the political actors.
Moreover, Libyans have a growing and tangible frustration toward the status quo, which can be harnessed to build momentum and pressure institutions to be more functional.
Salame's appointment, the presence of a constitutional draft, and a popular will for change together present a rare yet unpolished opportunity to reverse Libya's post-revolutionary descent into a failed state and regional source of instability.
If it is squandered, it is unclear when the next such opportunity will come to pass.
Tarek Megerisi is a Libyan political analyst and a visiting fellow at the European Council on Foreign Relations (ECFR).
Tarhuna, Mass Graves, and Libya's
Russian links with Libya general
The Roots of Authoritarianism in the Middle East (2)
The Libya Case in February 2017: Executive Summary
How Russia and Turkey sidelined Europe on Libya
For Benghazi, Justice Is Long Overdue
LIBYA SOCIAL MEDIA MONITORING REPORT (3)
Libyans Observe Bittersweet Anniversary
Rethinking the Arab Spring: (2/2) Uprisings
Libya has become a hub for online arms trading
What to Improve in the Arab World?
Libya's Next Elections: A Step Forward or a Step
Debts pile up as rival Libyan governments struggle
The Six Most Common Middle East Conspiracy Theories
Nawasi Brigade launches scathing attack on foreign
Why is Daesh's threat in Libya is not taken
Is it time to concede in Libya?
New UN Libya envoy faces long road to peace
Oil Prices Head Lower As Libyan Production Rebounds
Algeria-Libya: A New Demarcation Line between Two
Decisive, dissuasive will win in Libya
EU 'hypocrisy' condemns people to Libya
Bleeding Fuel
Russia's 'multilayered pie' policy on Libya
Libyan Dilemma and Egyptian National Security
Can new elections bring an end to the Libyan war?
A great war or is it peace? Libya is at a crucial
In Uncharted Waters (1): Islamic Parties Beyond