text:
Q: Using the conditional operator ? to check for null session variable Take a look at this code:
System.Web.SessionState.HttpSessionState ss = HttpContext.Current.Session["pdfDocument"] ?? false;

        if ((Boolean)ss)
        {
            Label1.Text = (String)Session["docName"];
        }

Basically I want to check if HttpContext.Current.Session["pdfDocument"] is not null, and if it isn't to cast to Boolean, then check if its true or false.
I'm trying to avoid nested if statements and figured there would be a more elegant way to do it.  I'm therefore only interested in answers that contain the conditional ? operator.
Any tips?

A: Why do you use ss variable?
What about this:
if (HttpContext.Current.Session["pdfDocument"] != null)
{
    Label1.Text = (String)Session["docName"];
}

A:     object ss = HttpContext.Current.Session["pdfDocument"] ?? false;
    if ((Boolean)ss)
    {
        Label1.Text = (String)Session["docName"];
    }

A: Not sure exactly what you're asking for, how about:
System.Web.SessionState.HttpSessionState ss;

Label1.Text = (Boolean)((ss = HttpContext.Current.Session["pdfDocument"]) ?? false) ? (String)Session["docName"] : Label1.Text;

Should leave ss with either a valid session or null, avoids the problem of trying to store false to ss and completely skips the subsequent 'if'. Though there's a repetition of Label1.Text.
Note: this has been edited to take account of the comment by Dave below.

A: The problem is that you can't do this:
SessionState.HttpSessionState ss = false;

Try putting your nested ifs into an extension method then call that instead.

A: You can try this, though I don't know if it fits your aesthetics:
bool isPdfDocumentSet =
     bool.TryParse((HttpContext.Current.Session["pdfDocument"] as string,
         out isPdfDocumentSet)
             ? isPdfDocumentSet
             : false;

EDIT: There is actually an even more concise way of doing it:
bool isPdfDocumentSet =
     bool.TryParse(HttpContext.Current.Session["pdfDocument"] as string,
          out isPdfDocumentSet) && isPdfDocumentSet;

A: HttpContext.Current.Session is an System.Web.SessionState.HttpSessionState object, which is a hash or dictionary, as some may call it, of different objects, so unless you're storing an HttpSessionState object as the "pdfDocument" location the first line is incorrect.
If you're actually storing a bool in the "pdfDocument" location which may or may not already be in this slot, you could cast that directly to a bool and null coalesce it: var ss = (bool)(HttpContext.Current.Session["pdfDocument"] ?? false);.
If you're possibly storing some other kind of object in the "pdfDocument" location you could just see if it's currently at that location by checking for null: var ss = HttpContext.Current.Session["pdfDocument"] != null;.

A: I think the closest you will get to the solution taking that path is following:
System.Web.SessionState.HttpSessionState ss = HttpContext.Current.Session["pdfDocument"];
if (ss != null)
{
    Label1.Text = (String)Session["docName"];
}


The comprehensive course covers Class I, IV, and V trucks. Students will be instructed on seven specific areas of forklift training which includes: fundamentals, balance and capacity, preoperational inspection, general rules of the road, safe load handling, techniques, refueling, and battery charging and changing.
Lorie Jones, Director of Community and Business Education for Texarkana College, said the grant from Texas Mutual allows TC to offer the course for only $25 to participants.
The curriculum is National Safety Council certified which prepares students to understand the importance of and demonstrate all safety requirements for a forklift inspection. For more information on class dates and times, please contact Jennifer Teeters at 903-823-3014 or jennifer.teeters@texarkanacollege.edu.


text:
Breda, város Hollandia déli részén, Észak-Brabant tartományban
Breda, település Spanyolországban, Girona tartományban.
Breda, település az USA-ban, Iowa államban, Carroll megyében

Hasonló névvel:
12710 Breda, Naprendszer kisbolygóövében található aszteroida.
Breda di Piave, település Olaszországban, Veneto régióban, Treviso megyében.
NAC Breda, holland labdarúgóklub Bredában.
Societá Italiana Ernesto Breda, olasz járműgyártó vállalat.
Breda 61, breda gyártmányú olasz féllánctalpas tüzérségi vontató.

redpajama_set_name: RedPajamaWikipedia


text:
MAYOR: Russia is not in need of financing from international financial organizations
MOSCOW, may 12. /TASS/. Russia does not need funding from international financial institutions, said the Minister of economic development of Russia Maxim Oreshkin.
"Financing the Russian economy now as the money is not very necessary, because we have balance of payments in good condition, and capital inflows have, therefore, money as such we do not need", – he told in interview to TV channel "Russia 24".
The Minister stressed that the Russian economy does not need funding, but in experience and knowledge, which will then be implemented in various economic fields.
About the rating of the EBRD
Oreshkin also said that Russia will prepare a letter and send to the rating Agency explaining why the rating of the Bank should be lower than AAA.
"We will prepare a special letter, send it to the rating agencies, where carefully explain what the problem is with the finances of the Bank and why he can't keep the AAA rating," said he.
Oreshkin stressed that the AAA rating a Bank must have a "sustainable capital base, clear model of development and clear return". "The departure from Russia is making in all these areas the situation is worse in the Bank", – said the Minister.
Informed. in a written statement to the annual meeting of the EBRD Board of governors pointed out that Russia considers the actions of the EBRD in relation to her "ethnic discrimination". In particular, he mentioned the adoption of "political leadership" for the complete cessation with Jul 2014 new investment in Russia.
Russia is a member of EBRD since 1992. In July 2014, the management of the Bank, guided by the political leadership of the Bank's shareholders from the EU, in connection with the sanctions imposed on Russia adopted a decision on "temporary suspension" of funding for new projects in Russia. All the years of the Russian Federation advocated the resumption of EBRD investments.
Sustainable growth of investment activity in the Russian Federation
Oreshkin noted the sustainable growth of investment activity in Russia from mid-2016.
"There are statistics of import of investment goods, and there are statistics of the production of goods of investment character within the country. We see that these two indicators suggests that investment activity starting from the middle of 2016 has been steadily rising," said the Minister.
As noted., the growth rate of imports of investment goods in 2017 amounted to "about 30% compared to last year." "Manufacturing within the country is also positive dynamics is much more modest but also positive," – said the head of the MAYOR.
However, said Oreshkin, Russia is lagging behind in the issue of infrastructure investment, as in the last two or three years "and at the level of the Federal budget and regional budgets, investment in infrastructure in the framework of the program of fiscal consolidation, have faced very serious cuts."
The achievement of the inflation target
… Confirmed that the inflation target of 4% will be reached already in may.
"We expect that the level of 4% will be reached already in may. Evaluation at the end of the year do not change. The baseline scenario of 3.8% subject to the weakening of the ruble. Assessments while maintaining a stable exchange rate is about 3%. We are proceeding along the path, which was presented at formation of the forecast", – said the head of the MAYOR.
According to Oreshkin, optimistic inflationary trend immediately followed by "completely adequate" response of the Central Bank, which has resulted in more aggressive reduction of the key rate.
At the beginning of April. presented an updated macroeconomic forecast for 2017 and the planning period until 2020. The government has considered three options for the forecast is a conservative, baseline and target, and made the basis for the so-called baseline scenario, which envisages inflation in Russia by the end of 2017 at the level of 3.8%.
The ruble
Oreshkin also confirmed the forecast of the exchange rate of the ruble in Russia in 2017 in the range of 62-63 per dollar RUB while maintaining current oil prices.
"At current oil prices, we have the exchange rate should come out somewhere in the range of above 60 rubles per dollar, 62-63 rubles per dollar. Here is the whole story remains," he said.
Previously, the Ministry reported that it expects a serious weakening of the ruble RUB to 63-64 to the dollar. In the baseline scenario of the macroeconomic forecast to 2020 the MAYOR expects the dollar at the end of the 2017 goal will be 68 rubles, by the end of 2018 and 70.8 RUB In the target (positive) version of the macroeconomic forecast the dollar at the end of 2017 is expected at the level of 68 rubles, by the end of 2018 – at the level of 70.3 RUB.
PreviousShares of AFK "System" on Masuria fell to the lowest since 2015
NextThe Ministry of justice offers to refund part of the insurance money in case of early repayment of the loan
The head of Twitter has donated 1% of the company shares in favor of employees
Chizhov did not rule out the possibility of revival of the project "South stream"
Source: Board of Directors "Transaero" can change Director
The dollar rose to 58,71, the Euro to RUB 64,62
Roskomnadzor: American online cinema Netflix have to pay taxes in Russia
The Governor of the Bank of Korea sees no threat to the economy after the decision of the U.S. Federal reserve

redpajama_set_name: RedPajamaCommonCrawl


FREEVIEW viewers in Henley are being reminded that they may need to retune their TV equipment on Wednesday to continue watching programmes.
This follows a change at the main Crystal Palace transmitter. Services will be subject to disruption during the day and work is expected to be completed late afternoon. Anyone who finds they are missing channels after this can retune.
Viewers who needs advice on retuning or more information can call the Freeview advice line free on 0808 100 0288 or visit www.freeview.


Have you received a text message or phone call from (0161) 233 2567? Read the comments below to determine who is calling from this phone number. Please share any additional information by posting a comment below.
The phone number 01612332567 appears to be registered with a phone company. The number is located in Manchester, in The United Kingdom.
The phone number (0161) 233 2567 has the area code 0161 which appears to be registered with a phone company and that is good news. Often times, telemarketers and spammers will use phone numbers that are very similar to yours with the last few digits changed. If you receive a phone call from a number you don't recognize and it is almost identical to yours, you should be careful answering or returning the call. Only answer or call the number back if you know who is calling and check back here often for any new comments posted below. If you do know who is calling from (0161) 233 2567, please let everyone know by posting a comment below.
Is (0161) 233 2567 Safe to Answer or a Spam Caller?
Comment: Have you received a phone call, text, or fax from 01612332567? Please leave a comment about it below.
Often telemarketers use similar phone numbers to make their calls so checking phone numbers around (0161) 233 2567 can help determine who is calling.
(0161) 233 3123: Jason from this company keeps calling about our life insurance. I've asked for them to write as they are only an agent. They keep calling so I've now blocked their number.
0300 200 3084: Caller states they are HMRC and if you do not press 1 a warrant for your arrest will be issued. This is a scam and very dangerous.
(01995) 822999: They claim they are forwarding a message from BT about cutting off my Broadband. I think they can disguise their actual number because it is always different and in a very remote part of the UK if it is identifiable.
They offer a couple of options on dialpad.
Several years ago it sounded like an Asian person but now it is pre-recorded in a posh English voice, either male or female! After years of calling the same number they must be pretty stupid to expect me to comply. Broadband has worked throughout! On one occasion they claimed to be from Talk Talk!
First time round I asked them for my account number and they responded immediately with one. When I looked it up, they had the right format but not the right number!
I informed BT who barred all foreign numbers which maybe why I only see uk numbers.


I'm trying to find several WW2 era Canadian or British signal wire spools for a radio truck restoration project I'm working on. Anyone know of any out there that might be had?
Any Pictures of what they would look like?
Here's a British one and an American one (used by us). There are other types, some made from wood but I think these are probably the ones that may still be around. I'd even settle for post war if they are somewhat close.


Through the years I've watched our trees that never seem to change.
those boys and girls seem ever young.
visions of them playing there.
there lies an open meadow.
in full pursuit of life.
never left my inner soul.
I recall each day with love.
thoughts abound, peace is found.
Our porch is now a deck.
Three sons have grown to men.
The barn is now one hundred-two years old.
The neighbor kids have grown.
They now have children and grandchildren of their own.
Our son, Tim, died five years ago.
all the times of joy and sadness.
We've entertained our friends at church picnics.
I now have a deck swing that I love.
You will love it the longer you have it. It's such a wonderful place in the early morning when all is quiet and the birds are starting to sing. Again, in the evening at dusk. Guess you can see I'm hooked on it. Thank you for liking and reading this one and I hope some of my other posts.


Do you know about the book: PostSecret: Extraordinary Confessions from Ordinary Lives ? It all began with an idea Frank Warren had for a community art project. He began handing out postcards to strangers and leaving them in public places -- asking people to write down a secret they had never told anyone and mail it to him, anonymously. Well now there's a Post Secret Blog. You're sure to be engrossed.


text:
use fnv;

use crate::ast::ExprKind::*;
use crate::ast::*;

use fnv::FnvHashMap;

use std::mem;

#[cfg(test)]
use crate::tests::*;

/// Inlines GetField(MakeStruct(*)) expressions, which can occur during loop fusion when some
/// of the loops are zipping together multiple column vectors.
pub fn inline_get_field(expr: &mut Expr) {
    expr.transform(&mut |ref mut expr| {
        if let GetField { ref expr, index } = expr.kind {
            if let MakeStruct { ref elems } = expr.kind {
                return Some(elems[index as usize].clone());
            }
        }
        None
    });
}

/// Inlines Zip expressions as collections of iters. Using Zips outside of a For loop is currently
/// unsupported behavior. This transform handles the simple case of converting Zips in macros
/// such as map and filter into Iters in For loops.
///
/// TODO(shoumik): Perhaps Zip should just be a macro? Then macros need to be ordered.
pub fn inline_zips(expr: &mut Expr) {
    expr.transform(&mut |ref mut e| {
        if let For {
            ref mut iters,
            ref builder,
            ref func,
        } = e.kind
        {
            if iters.len() == 1 {
                let first_iter = &iters[0];
                if let Zip { ref vectors } = first_iter.data.kind {
                    let new_iters = vectors
                        .iter()
                        .map(|v| Iter {
                            data: Box::new(v.clone()),
                            start: None,
                            end: None,
                            stride: None,
                            kind: first_iter.kind.clone(),
                            shape: None,
                            strides: None,
                        })
                        .collect::<Vec<_>>();
                    return Some(Expr {
                        ty: e.ty.clone(),
                        kind: For {
                            iters: new_iters,
                            builder: builder.clone(),
                            func: func.clone(),
                        },
                        annotations: Annotations::new(),
                    });
                }
            }
        }
        None
    });
}

/// Inlines Apply nodes whose argument is a Lambda expression. These often arise during macro
/// expansion but it's simpler to inline them before doing type inference.
/// Unlike many of the other transformations, we make this one independent of types so that
/// we can apply it before type inference.
///
/// Caveats:
/// - Functions that reuse a parameter twice have its expansion appear twice, instead of assigning
///   it to a temporary as would happen with function application.
/// - Does not complete inlining if some of the functions take functions as arguments (in that
///   case, the expressions after inlining may lead to more inlining).
pub fn inline_apply(expr: &mut Expr) {
    expr.transform(&mut |ref mut expr| {
        if let Apply {
            ref func,
            params: ref args,
        } = expr.kind
        {
            if let Lambda {
                ref params,
                ref body,
            } = func.kind
            {
                let mut new = *body.clone();
                for (param, arg) in params.iter().zip(args) {
                    new.substitute(&param.name, &arg);
                }
                return Some(new);
            }
        }
        None
    });
}

pub fn inline_let(expr: &mut Expr) {
    expr.uniquify().unwrap();
    let usages = &mut FnvHashMap::default();
    count_symbols(expr, usages);
    trace!("Symbol count: {:?}", usages);
    inline_let_helper(expr, usages)
}

#[derive(Debug)]
struct SymbolTracker {
    count: i32,
    loop_nest: i32,
    value: Option<Box<Expr>>,
}

impl Default for SymbolTracker {
    fn default() -> SymbolTracker {
        SymbolTracker {
            count: 0,
            loop_nest: 0,
            value: None,
        }
    }
}

/// Count the occurances of each symbol defined by a `Let` statement.
fn count_symbols(expr: &Expr, usage: &mut FnvHashMap<Symbol, SymbolTracker>) {
    match expr.kind {
        For { ref func, .. }
        | Iterate {
            update_func: ref func,
            ..
        }
        | Sort {
            cmpfunc: ref func, ..
        }
        | Apply { ref func, .. } => {
            // Mark all symbols seen so far as "in a loop"
            for value in usage.values_mut() {
                value.loop_nest += 1;
            }

            count_symbols(func, usage);

            for value in usage.values_mut() {
                value.loop_nest -= 1;
            }
        }
        Let { ref name, .. } => {
            debug_assert!(!usage.contains_key(name));
            let _ = usage.insert(name.clone(), SymbolTracker::default());
        }
        Ident(ref symbol) => {
            if let Some(ref mut tracker) = usage.get_mut(symbol) {
                if tracker.loop_nest == 0 {
                    tracker.count += 1;
                } else {
                    // Used in a loop!
                    tracker.count += 3;
                }
            }
        }
        _ => (),
    };

    // Recurse into children - skip functions that expressions may call repeatedly. We handled
    // those already.
    for child in expr.children() {
        match child.kind {
            Lambda { .. } => (),
            _ => count_symbols(child, usage),
        }
    }
}

/// Inlines Let calls if the symbol defined by the Let statement is used
/// never or only one time.
fn inline_let_helper(expr: &mut Expr, usages: &mut FnvHashMap<Symbol, SymbolTracker>) {
    let mut taken_body = None;
    match expr.kind {
        Let {
            ref mut name,
            ref mut value,
            ref mut body,
        } => {
            // Check whether the symbol is used one or fewer times.
            if let Some(tracker) = usages.get_mut(name) {
                if tracker.count <= 1 {
                    taken_body = Some(body.take());
                    tracker.value = Some(value.take());
                }
            }
        }
        Ident(ref name) => {
            // Check if the identifier maps to one that should be inlined.
            if let Some(tracker) = usages.get_mut(name) {
                if tracker.count <= 1 {
                    // Value should have been set by a preceding Let.
                    debug_assert!(tracker.value.is_some());
                    // Value should only be swapped once.
                    debug_assert!(!tracker.value.as_ref().unwrap().is_placeholder());
                    mem::swap(&mut taken_body, &mut tracker.value);
                }
            }
        }
        _ => (),
    }

    // Set the body to this expression.
    if let Some(mut val) = taken_body {
        mem::swap(expr, val.as_mut());
        inline_let_helper(expr, usages);
    } else {
        for child in expr.children_mut() {
            inline_let_helper(child, usages);
        }
    }
}

/// Changes negations of literal values to be literal negated values.
pub fn inline_negate(expr: &mut Expr) {
    use crate::ast::LiteralKind::*;
    expr.transform(&mut |ref mut expr| {
        if let Negate(ref child_expr) = expr.kind {
            if let Literal(ref literal_kind) = child_expr.kind {
                let res = match *literal_kind {
                    I8Literal(a) => Some(Expr::new_literal(I8Literal(-a)).unwrap()),
                    I16Literal(a) => Some(Expr::new_literal(I16Literal(-a)).unwrap()),
                    I32Literal(a) => Some(Expr::new_literal(I32Literal(-a)).unwrap()),
                    I64Literal(a) => Some(Expr::new_literal(I64Literal(-a)).unwrap()),
                    F32Literal(a) => {
                        Some(Expr::new_literal(F32Literal((-f32::from_bits(a)).to_bits())).unwrap())
                    }
                    F64Literal(a) => {
                        Some(Expr::new_literal(F64Literal((-f64::from_bits(a)).to_bits())).unwrap())
                    }
                    _ => None,
                };
                return res;
            }
        }
        None
    });
}

/// Inline casts.
///
/// This changes casts of literal values to be literal values of the casted type. It additionally
/// removes "self casts" (e.g., `i64(x: i64)` becomes `x`).
pub fn inline_cast(expr: &mut Expr) {
    use crate::ast::LiteralKind::*;
    use crate::ast::ScalarKind::*;
    use crate::ast::Type::Scalar;
    expr.transform(&mut |ref mut expr| {
        if let Cast {
            kind: ref scalar_kind,
            ref child_expr,
        } = expr.kind
        {
            if let Literal(ref literal_kind) = child_expr.kind {
                return match (scalar_kind, literal_kind) {
                    (&F64, &I32Literal(a)) => {
                        Some(Expr::new_literal(F64Literal((f64::from(a)).to_bits())).unwrap())
                    }
                    (&I64, &I32Literal(a)) => {
                        Some(Expr::new_literal(I64Literal(i64::from(a))).unwrap())
                    }
                    (&F64, &I64Literal(a)) => {
                        Some(Expr::new_literal(F64Literal((a as f64).to_bits())).unwrap())
                    }
                    _ => None,
                };
            }
            if let Scalar(ref kind) = child_expr.ty {
                if kind == scalar_kind {
                    // XXX Tombstone and mem::swap here!!
                    return Some(*child_expr.clone());
                }
            }
        }
        None
    });
}

/// Checks if `expr` is a `GetField` on an identifier with name `sym`. If so,
/// returns the field index being accessed.
fn getfield_on_symbol(expr: &Expr, sym: &Symbol) -> Option<u32> {
    if let GetField {
        ref expr,
        ref index,
    } = expr.kind
    {
        if let Ident(ref ident_name) = expr.kind {
            if sym == ident_name {
                return Some(*index);
            }
        }
    }
    None
}

/// Simplifies branches with `<expr> == False` to just be over <expr>`
///
/// This switches the true condition and the false condition.
pub fn simplify_branch_conditions(expr: &mut Expr) {
    use crate::ast::LiteralKind::BoolLiteral;
    expr.uniquify().unwrap();
    expr.transform_up(&mut |ref mut expr| {
        if let If {
            ref mut cond,
            ref mut on_true,
            ref mut on_false,
        } = expr.kind
        {
            let mut taken = None;
            if let BinOp {
                ref mut kind,
                ref mut left,
                ref mut right,
            } = cond.kind
            {
                if *kind == BinOpKind::Equal {
                    if let Literal(BoolLiteral(false)) = left.kind {
                        taken = Some(right.take());
                    } else if let Literal(BoolLiteral(false)) = right.kind {
                        taken = Some(left.take());
                    }
                }
            };

            if let Some(ref mut expr) = taken {
                mem::swap(cond, expr);
                mem::swap(on_true, on_false);
            }
        }
        // We just updated the expression in place instead of replacing it.
        None
    });
}

/// Changes struct definitions assigned to a name and only used in `GetField` operations
/// to `Let` definitions over the struct elements themselves.
///
/// This transformation is similar to a simple SROA (scalar replacement of aggregates) transform in
/// other compilers.
///
/// ## Example
///
/// let a = {1, 2, 3, 4};
/// a.$0 + a.$1 + a.$2
///
/// Becomes
///
/// let us = 1;
/// let us#1 = 2;
/// let us#1 = 3;
/// let us#1 = 4;
/// us + us#1 + us#2
///
pub fn unroll_structs(expr: &mut Expr) {
    use crate::util::SymbolGenerator;

    expr.uniquify().unwrap();
    let mut sym_gen = SymbolGenerator::from_expression(expr);
    expr.transform_up(&mut |ref mut expr| {
        if let Let {
            ref name,
            ref value,
            ref body,
        } = expr.kind
        {
            if let MakeStruct { ref elems } = value.kind {
                // First, ensure that the name is not used anywhere but a `GetField`.
                let mut total_count: i32 = 0;
                let mut getstruct_count: i32 = 0;
                body.traverse(&mut |ref e| {
                    if getfield_on_symbol(e, name).is_some() {
                        getstruct_count += 1;
                    }
                    if let Ident(ref ident_name) = e.kind {
                        if ident_name == name {
                            total_count += 1;
                        }
                    }
                });

                // We used the struct somewhere else, so we can't safely get rid of it.
                if total_count != getstruct_count {
                    return None;
                }

                let mut new_body = body.as_ref().clone();
                let symbols: Vec<_> = elems.iter().map(|_| sym_gen.new_symbol("us")).collect();
                // Replace the new_body with the symbol we assigned the struct element to.
                new_body.transform(&mut |ref mut expr2| {
                    if let Some(index) = getfield_on_symbol(expr2, name) {
                        let sym = symbols[index as usize].clone();
                        return Some(Expr::new_ident(sym, expr2.ty.clone()).unwrap());
                    }
                    None
                });

                // Unroll the struct elements by assigning each one to a name.
                let mut prev = new_body;
                for (i, sym) in symbols.into_iter().enumerate().rev() {
                    prev = Expr::new_let(sym, elems[i].clone(), prev).unwrap();
                }
                return Some(prev);
            }
        }
        None
    });
}

#[test]
fn inline_lets() {
    let mut e1 = typed_expression("let a = 1; a + 2");
    inline_let(&mut e1);
    let e2 = typed_expression("1 + 2");
    assert!(e1.compare_ignoring_symbols(&e2).unwrap());

    let mut e1 = typed_expression("let a = 1; a + a + 2");
    // The transform should fail since the identifier is used more than once.
    inline_let(&mut e1);
    let e2 = typed_expression("let a = 1; a + a + 2");
    assert!(e1.compare_ignoring_symbols(&e2).unwrap());

    let mut e1 = typed_expression(
        "let a = 1L; for([1L,2L,3L], appender, |b,i,e| merge(b, e + a \
         + 2L))",
    );
    inline_let(&mut e1);
    // The transform should fail since the identifier is used in a loop.
    let e2 = typed_expression(
        "let a = 1L; for([1L,2L,3L], appender, |b,i,e| merge(b, e + a + \
         2L))",
    );
    assert!(e1.compare_ignoring_symbols(&e2).unwrap());

    let mut e1 = typed_expression("let a = 1; let b = 2; let c = 3; a + b + c");
    inline_let(&mut e1);
    let e2 = typed_expression("1 + 2 + 3");
    assert!(e1.compare_ignoring_symbols(&e2).unwrap());

    let mut e1 = typed_expression(
        "|input: vec[i32]|
        let b = 1;
        result(for(input, merger[i32,+], |b,i,e| let a = 1; merge(b, e + a))) + b",
    );
    inline_let(&mut e1);

    let e2 = typed_expression(
        "|input: vec[i32]|
        result(for(input, merger[i32,+], |b,i,e| merge(b, e + 1))) + 1",
    );
    assert!(e1.compare_ignoring_symbols(&e2).unwrap());

    let mut e1 = typed_expression(
        "|input: vec[i32]|
        let b = 1;
        result(for(input, merger[i32,+], |b,i,e| let a = 1; merge(b, e + a + a))) + b",
    );
    inline_let(&mut e1);

    let e2 = typed_expression(
        "|input: vec[i32]|
        result(for(input, merger[i32,+], |b,i,e| let a = 1; merge(b, e + a + a))) + 1",
    );
    assert!(e1.compare_ignoring_symbols(&e2).unwrap());
}

redpajama_set_name: RedPajamaGithub


It is a well known fact that Latin American girls and Colombian women in general are very hot, gorgeous and seductive, it will be only safe to say that they are men magnets, and that's why many men fancy Latin hot woman and the main reason why every man wants to date Latin girls.
However, if you are a foreigner and still want to date hot Latin American girls, you must do your home work, to cherish the beauty of a Latin girl you must make yourself aware about the Latin culture and traditions. Latin women seeking men usually are very family oriented so if you are eager to meet Colombian girls then begin with learning about their rich culture and traditions. Columbian hot women are raised to be good wives as they know how to keep a man happy, you must first try to understand which part of Columbia they hail from and learn accordingly.
Men often crib that they feel suffocated as beauty latin girl don't give them space in their relationships. However justified, this accusation seems quite over the top. So ignoring a man is subtle way of showing him that too much "space" can also create distance between the couple.
Making a man jealous in a relationship is another motive for ignoring him. If in your relationship you don't feel that you are getting enough affection or indulgence from your boy friend ignoring him is another way of making him jealous so he get alerted that his relationship needs serious attention.
Showing your angry side to your spouse means that you want him to know he behaved very badly and then silence or indifference, will further strengthen your stance and will give him the message. He will understand that you are angry, but trying to avoid direct confrontation.
Another reason for the ignorance could be that your spouse actually wants to dump you, as ignoring a man is a sign that the woman wants out or wants to end the relationship, or it could be seen as a break up sign also. If a relationship is not progressing or not working out for some reason, then girls look for reasons to end it as there's no point of dragging something which is not functioning, ignoring the guy seems like a nice idea as it will slowly make him accept the inevitable fate and give him time to adapt to it, instead of breaking it off drastically which could be emotionally challenging for him.
Sometimes dating latin ladies use it as a strategy to ignore the man who is taking too long to propose, so they drop these subtle hints to make him pop the question sooner. Men are rather slow at picking up hints especially when it comes to marriage, if you want him to pop the question you should try ignoring him it will make him weary or concerned and he might actually get the hint and propose to you, as it will make him insecure and he doesn't want to lose you.


What's the role of humor in an open society? And can comedy be an effective tool for increasing tolerance, changing attitudes, and promoting social justice?
In this video, Open Society Foundations colleagues, partners, and grantees talk about how activists, civil society organizations, comedians, humorists, and journalists from throughout Latin America are using comedy to tear down prejudice, expose corruption, and offer a vision of a better world.
Es lo más divertido que escucho en décadas, lo que me llama la atención es que creo que la realidad me divierte y me pregunto ¿como podemos aguantar a esos políticos corruptos que nos gobiernen?
Of all genres, comedy and satire are possible the most effective in a political climate where people are tired of the same narratives. Humor, good one, is always helpful to make the point.
Of course, in countries such as Colombia, major comedians and other social critics have been killed.
Felipe Cala is a senior program officer at the Open Society Latin America Program.


text:
int countOccurrences(std::string word, std::string &document) {
    int count = 0;
    for (size_t pos = document.find(word); pos != std::string::npos; pos = document.find(word, pos + word.length())) {
        count++;
    }
    return count;
}

void testAutobahn() {
    uWS::Hub h;

    uWS::Group<uWS::SERVER> *sslGroup = h.createGroup<uWS::SERVER>(uWS::PERMESSAGE_DEFLATE);
    uWS::Group<uWS::SERVER> *group = h.createGroup<uWS::SERVER>(uWS::PERMESSAGE_DEFLATE);

    auto messageHandler = [](uWS::WebSocket<uWS::SERVER> *ws, char *message, size_t length, uWS::OpCode opCode) {
        ws->send(message, length, opCode);
    };

    sslGroup->onMessage(messageHandler);
    group->onMessage(messageHandler);

    sslGroup->onDisconnection([sslGroup](uWS::WebSocket<uWS::SERVER> *ws, int code, char *message, size_t length) {
        static int disconnections = 0;
        if (++disconnections == 519) {
            std::cout << "SSL server done with Autobahn, shutting down!" << std::endl;
            sslGroup->close();
        }
    });

    group->onDisconnection([group](uWS::WebSocket<uWS::SERVER> *ws, int code, char *message, size_t length) {
        static int disconnections = 0;
        if (++disconnections == 519) {
            std::cout << "Non-SSL server done with Autobahn, shutting down!" << std::endl;
            group->close();
        }
    });

    uS::TLS::Context c = uS::TLS::createContext("misc/ssl/cert.pem",
                                                "misc/ssl/key.pem",
                                                "1234");
    if (!h.listen(3001, c, 0, sslGroup) || !h.listen(3000, nullptr, 0, group)) {
        std::cout << "FAILURE: Error listening for Autobahn connections!" << std::endl;
        exit(-1);
    } else {
        std::cout << "Acepting Autobahn connections (SSL/non-SSL)" << std::endl;
    }

    std::thread t([]() {
        if (!system("wstest -m fuzzingclient -s misc/Autobahn.json")) {

        }
    });

    h.run();
    t.join();

    // "FAILED", "OK", "NON-STRICT"
    std::ifstream fin("misc/autobahn/index.json");
    fin.seekg (0, fin.end);
    int length = fin.tellg();
    fin.seekg (0, fin.beg);
    char *buffer = new char[length];
    fin.read(buffer, length);
    std::string index(buffer, length);

    std::cout << std::endl << std::endl;
    std::cout << "OK: " << countOccurrences("\"OK\"", index) << std::endl;
    std::cout << "NON-STRICT: " << countOccurrences("\"NON-STRICT\"", index) << std::endl;
    std::cout << "FAILED: " << countOccurrences("\"FAILED\"", index) << std::endl;

    delete sslGroup;
    delete group;
    delete [] buffer;
}

void serveBenchmark() {
    uWS::Hub h;

    h.onMessage([&h](uWS::WebSocket<uWS::SERVER> *ws, char *message, size_t length, uWS::OpCode opCode) {
        ws->send(message, length, opCode);
    });

    //h.getDefaultGroup<uWS::SERVER>().startAutoPing(1000);
    h.listen(3000);
    h.run();
}

void measureInternalThroughput(unsigned int payloadLength, int echoes, bool ssl) {
    uWS::Hub h;

    char *payload = new char[payloadLength];
    for (unsigned int i = 0; i < payloadLength; i++) {
        payload[i] = rand();
    }

    const char *closeMessage = "I'm closing now";
    size_t closeMessageLength = strlen(closeMessage);

    uS::TLS::Context c = uS::TLS::createContext("misc/ssl/cert.pem",
                                                "misc/ssl/key.pem",
                                                "1234");

    h.onConnection([payload, payloadLength, echoes](uWS::WebSocket<uWS::CLIENT> *ws, uWS::HttpRequest req) {
        for (int i = 0; i < echoes; i++) {
            ws->send(payload, payloadLength, uWS::OpCode::BINARY);
        }
    });

    h.onError([](void *user) {
        std::cout << "FAILURE: Connection failed! Timeout?" << std::endl;
        exit(-1);
    });

    h.onMessage([payload, payloadLength, closeMessage, closeMessageLength, echoes](uWS::WebSocket<uWS::CLIENT> *ws, char *message, size_t length, uWS::OpCode opCode) {
        if (strncmp(message, payload, payloadLength) || payloadLength != length) {
            std::cout << "FAIL: Messages differ!" << std::endl;
            exit(-1);
        }

        static int echoesPerformed = 0;
        if (echoesPerformed++ == echoes) {
            echoesPerformed = 0;
            ws->close(1000, closeMessage, closeMessageLength);
        } else {
            ws->send(payload, payloadLength, opCode);
        }
    });

    h.onDisconnection([](uWS::WebSocket<uWS::CLIENT> *ws, int code, char *message, size_t length) {
        std::cout << "CLIENT CLOSE: " << code << std::endl;
    });

    h.onMessage([](uWS::WebSocket<uWS::SERVER> *ws, char *message, size_t length, uWS::OpCode opCode) {
        ws->send(message, length, opCode);
    });

    h.onDisconnection([&h, closeMessage, closeMessageLength](uWS::WebSocket<uWS::SERVER> *ws, int code, char *message, size_t length) {
        std::cout << "SERVER CLOSE: " << code << std::endl;
        if (!length) {
            std::cout << "FAIL: No close message! Code: " << code << std::endl;
            exit(-1);
        }

        if (strncmp(message, closeMessage, closeMessageLength) || closeMessageLength != length) {
            std::cout << "FAIL: Close message differ!" << std::endl;
            exit(-1);
        }

        if (code != 1000) {
            std::cout << "FAIL: Close code differ!" << std::endl;
            exit(-1);
        }

        h.getDefaultGroup<uWS::SERVER>().close();
    });

    // we need to update libuv internal timepoint!
#ifndef USE_ASIO
    h.run();
#endif

    if (ssl) {
        if (!h.listen(3000, c)) {
            std::cout << "FAIL: ERR_LISTEN" << std::endl;
            exit(-1);
        }
        h.connect("wss://localhost:3000", nullptr);
    } else {
        if (!h.listen(3000)) {
            std::cout << "FAIL: ERR_LISTEN" << std::endl;
            exit(-1);
        }
        h.connect("ws://localhost:3000", nullptr);
    }

    std::chrono::time_point<std::chrono::high_resolution_clock> start, end;
    start = std::chrono::high_resolution_clock::now();
    h.run();
    end = std::chrono::high_resolution_clock::now();
    int ms = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    if (!ms) {
        std::cout << "Too small load!" << std::endl;
    } else {
        std::cout << "Throughput: " << (float(echoes) / float(ms)) << " echoes/ms (" << ms << " ms elapsed)" << std::endl;
    }

    delete [] payload;
}

void testStress() {
    for (int i = 0; i < 25; i++) {
        int payloadLength = std::pow(2, i);
        int echoes = 1;//std::max<int>(std::pow(2, 24 - i) / 50, 1);

        std::cout << "[Size: " << payloadLength << ", echoes: " << echoes << "]" << std::endl;
        for (int ssl = 0; ssl < 2; ssl++) {
            std::cout << "SSL: " << bool(ssl) << std::endl;
            measureInternalThroughput(payloadLength, echoes, ssl);
        }
    }
}

void testConnections() {
    uWS::Hub h;

    h.onError([](void *user) {
        switch ((long) user) {
        case 1:
            std::cout << "Client emitted error on invalid URI" << std::endl;
            break;
        case 2:
            std::cout << "Client emitted error on resolve failure" << std::endl;
            break;
        case 3:
            std::cout << "Client emitted error on connection timeout (non-SSL)" << std::endl;
            break;
        case 5:
            std::cout << "Client emitted error on connection timeout (SSL)" << std::endl;
            break;
        case 6:
            std::cout << "Client emitted error on HTTP response without upgrade (non-SSL)" << std::endl;
            break;
        case 7:
            std::cout << "Client emitted error on HTTP response without upgrade (SSL)" << std::endl;
            break;
        case 10:
            std::cout << "Client emitted error on poll error" << std::endl;
            break;
        case 11:
            static int protocolErrorCount = 0;
            protocolErrorCount++;
            std::cout << "Client emitted error on invalid protocol" << std::endl;
            if (protocolErrorCount > 1) {
                std::cout << "FAILURE:  " << protocolErrorCount << " errors emitted for one connection!" << std::endl;
                exit(-1);
            }
            break;
        default:
            std::cout << "FAILURE: " << user << " should not emit error!" << std::endl;
            exit(-1);
        }
    });

    h.onConnection([](uWS::WebSocket<uWS::CLIENT> *ws, uWS::HttpRequest req) {
        switch ((long) ws->getUserData()) {
        case 8:
            std::cout << "Client established a remote connection over non-SSL" << std::endl;
            ws->close(1000);
            break;
        case 9:
            std::cout << "Client established a remote connection over SSL" << std::endl;
            ws->close(1000);
            break;
        default:
            std::cout << "FAILURE: " << ws->getUserData() << " should not connect!" << std::endl;
            exit(-1);
        }
    });

    h.onDisconnection([](uWS::WebSocket<uWS::CLIENT> *ws, int code, char *message, size_t length) {
        std::cout << "Client got disconnected with data: " << ws->getUserData() << ", code: " << code << ", message: <" << std::string(message, length) << ">" << std::endl;
    });

    h.connect("invalid URI", (void *) 1);
    h.connect("invalid://validButUnknown.yolo", (void *) 11);
    h.connect("ws://validButUnknown.yolo", (void *) 2);
    h.connect("ws://echo.websocket.org", (void *) 3, {}, 10);
    h.connect("ws://echo.websocket.org", (void *) 8);
    h.connect("wss://echo.websocket.org", (void *) 5, {}, 10);
    h.connect("wss://echo.websocket.org", (void *) 9);
    h.connect("ws://google.com", (void *) 6);
    h.connect("wss://google.com", (void *) 7);
    h.connect("ws://127.0.0.1:6000", (void *) 10, {}, 60000);

    h.run();
    std::cout << "Falling through testConnections" << std::endl;
}

void testListening() {
    uWS::Hub h;

    h.onError([](int port) {
        switch (port) {
        case 80:
            std::cout << "Server emits error listening to port 80 (permission denied)" << std::endl;
            break;
        case 3000:
            std::cout << "Server emits error listening to port 3000 twice" << std::endl;
            break;
        default:
            std::cout << "FAILURE: port " << port << " should not emit error" << std::endl;
            exit(-1);
        }
    });

    h.listen(80);
    if (h.listen(3000)) {
        std::cout << "Server listens to port 3000" << std::endl;
    }
    h.listen(3000);
    h.getDefaultGroup<uWS::SERVER>().close();
    h.run();
    std::cout << "Server falls through after group closes" << std::endl;
}

void testClosing() {
    uWS::Hub h;
    const char *closeMessage = "Closing you down!";

    h.onConnection([&h, closeMessage](uWS::WebSocket<uWS::SERVER> *ws, uWS::HttpRequest req) {
        ws->terminate();
        h.onConnection([&h, closeMessage](uWS::WebSocket<uWS::SERVER> *ws, uWS::HttpRequest req) {
            ws->close(1000, closeMessage, strlen(closeMessage));
        });
        h.connect("ws://localhost:3000", (void *) 2);
    });

    h.onDisconnection([closeMessage](uWS::WebSocket<uWS::CLIENT> *ws, int code, char *message, size_t length) {
        switch ((long) ws->getUserData()) {
        case 1:
            if (code == 1006) {
                std::cout << "Client gets terminated on first connection" << std::endl;
            } else {
                std::cout << "FAILURE: Terminate leads to invalid close code!" << std::endl;
                exit(-1);
            }
            break;
        case 2:
            if (code == 1000 && length == strlen(closeMessage) && !strncmp(closeMessage, message, length)) {
                std::cout << "Client gets closed on second connection with correct close code" << std::endl;
            } else {
                std::cout << "FAILURE: Close leads to invalid close code or message!" << std::endl;
                exit(-1);
            }
            break;
        }
    });

    h.onDisconnection([&h, closeMessage](uWS::WebSocket<uWS::SERVER> *ws, int code, char *message, size_t length) {
        if (code == 1006) {
            std::cout << "Server recives terminate close code after terminating" << std::endl;
        } else if (code != 1000) {
            std::cout << "FAILURE: Server does not receive correct close code!" << std::endl;
            exit(-1);
        } else {
            std::cout << "Server receives correct close code after closing" << std::endl;
            h.getDefaultGroup<uWS::SERVER>().close();
        }
    });

    if (!h.listen(3000)) {
        std::cout << "FAILURE: Cannot listen to port 3000!" << std::endl;
        exit(-1);
    }
    h.connect("ws://localhost:3000", (void *) 1);

    h.run();
    std::cout << "Falling through after testClosing!" << std::endl;
}

void testBroadcast() {
    uWS::Hub h;

    const char *broadcastMessage = "This will be broadcasted!";
    size_t broadcastMessageLength = strlen(broadcastMessage);

    int connections = 14;
    h.onConnection([&h, &connections, broadcastMessage, broadcastMessageLength](uWS::WebSocket<uWS::SERVER> *ws, uWS::HttpRequest req) {
        if (!--connections) {
            std::cout << "Broadcasting & closing now!" << std::endl;
            h.getDefaultGroup<uWS::SERVER>().broadcast(broadcastMessage, broadcastMessageLength, uWS::OpCode::TEXT);
            h.getDefaultGroup<uWS::SERVER>().close();
        }
    });

    int broadcasts = connections;
    h.onMessage([&broadcasts, broadcastMessage, broadcastMessageLength](uWS::WebSocket<uWS::CLIENT> *ws, char *message, size_t length, uWS::OpCode opCode) {
        if (length != broadcastMessageLength || strncmp(message, broadcastMessage, broadcastMessageLength)) {
            std::cout << "FAILURE: bad broadcast message!" << std::endl;
            exit(-1);
        } else {
            broadcasts--;
        }
    });

    h.onDisconnection([](uWS::WebSocket<uWS::CLIENT> *ws, int code, char *message, size_t length) {
        if (code != 1000) {
            std::cout << "FAILURE: Invalid close code!" << std::endl;
            exit(-1);
        }
    });

    h.listen(3000);

    for (int i = 0; i < connections; i++) {
        h.connect("ws://localhost:3000", nullptr);
    }

    h.run();

    if (broadcasts != 0) {
        std::cout << "FAILURE: Invalid amount of broadcasts received!" << std::endl;
        exit(-1);
    }

    std::cout << "Falling through now!" << std::endl;
}

void testRouting() {
    uWS::Hub h;

    int correctStrings = 0;

    h.onConnection([&correctStrings](uWS::WebSocket<uWS::CLIENT> *ws, uWS::HttpRequest req) {
        if (req.getHeader("sec-websocket-protocol").toString() == "someSubProtocolHere") {
            correctStrings++;
        }
        ws->close();
    });

    h.onConnection([&correctStrings](uWS::WebSocket<uWS::SERVER> *ws, uWS::HttpRequest req) {
        if (req.getHeader("sec-websocket-protocol").toString() == "someSubProtocolHere") {
            correctStrings++;
        }

        if (req.getHeader("some-random-header").toString() == "someRandomValue") {
            correctStrings++;
        }

        if (req.getUrl().toString() == "/somePathHere") {
            correctStrings++;
        }
    });

    h.onDisconnection([&h](uWS::WebSocket<uWS::SERVER> *ws, int code, char *message, size_t length) {
        h.getDefaultGroup<uWS::SERVER>().close();
    });

    h.listen(3000);
    h.connect("ws://localhost:3000/somePathHere", nullptr, {{"sec-websocket-protocol", "someSubProtocolHere"}, {"some-random-header", "someRandomValue"}});

    h.run();

    if (correctStrings != 4) {
        std::cout << "FAILURE: incorrect paths or subprotocols " << correctStrings << std::endl;
        exit(-1);
    } else {
        std::cout << "testRouting passed, falling through" << std::endl;
    }
}

void testReusePort() {
    uWS::Hub h;

    uWS::Group<uWS::SERVER> *group1 = h.createGroup<uWS::SERVER>();
    uWS::Group<uWS::SERVER> *group2 = h.createGroup<uWS::SERVER>();

    if (h.listen(3000, nullptr, uS::REUSE_PORT, group1) && h.listen(3000, nullptr, uS::REUSE_PORT, group2)) {
        std::cout << "Can listen to same port twice!" << std::endl;
    } else {
        std::cout << "FAILURE: Cannot listen to same port twice!" << std::endl;
        exit(-1);
    }

    group1->close();
    group2->close();

    h.run();

    delete group1;
    delete group2;
}

void testTransfers() {
    for (int ssl = 0; ssl < 2; ssl++) {
        uWS::Group<uWS::SERVER> *tServerGroup = nullptr;
        uWS::Group<uWS::CLIENT> *clientGroup = nullptr;

        int receivedMessages = 0;

        std::mutex m;
        uWS::WebSocket<uWS::CLIENT> *client;

        std::thread t([&tServerGroup, &client, &receivedMessages, &clientGroup, &m]{
            uWS::Hub th;
            tServerGroup = &th.getDefaultGroup<uWS::SERVER>();

            bool transferred = false;

            th.onTransfer([&transferred](uWS::WebSocket<uWS::SERVER> *ws) {
                if (ws->getUserData() != (void *) 12345) {
                    std::cout << "onTransfer called with websocket with invalid user data set!" << std::endl;
                    exit(-1);
                }

                transferred = true;
            });

            th.onMessage([&tServerGroup, &client, &receivedMessages, &clientGroup, &m, &transferred](uWS::WebSocket<uWS::SERVER> *ws, char *message, size_t length, uWS::OpCode opCode) {
                if (!transferred) {
                    std::cout << "FAILURE: onTransfer was not triggered in time" << std::endl;
                    exit(-1);
                }

                switch(++receivedMessages) {
                case 1:
                    m.lock();
                    client->send("second message");
                    m.unlock();
                    break;
                case 2: {
                    const char *str = "some broadcast here";
                    clientGroup->broadcast(str, strlen(str), uWS::OpCode::TEXT);
                    break;
                }
                case 3: {
                    usleep(10000);
                    char *tmp = new char[1024 * 1024 * 16];
                    memset(tmp, 0, 1024 * 1024 * 16);
                    client->send(tmp, 1024 * 1024 * 16, uWS::OpCode::BINARY);
                    delete [] tmp;
                    break;
                }
                case 4:
                    tServerGroup->close();
                    break;
                }

                if (opCode != uWS::OpCode::BINARY) {
                    std::cout << "Message " << receivedMessages << ": " << std::string(message, length) << std::endl;
                } else {
                    std::cout << "Message " << receivedMessages << ": binary" << std::endl;
                }
            });

            th.getDefaultGroup<uWS::SERVER>().listen(uWS::TRANSFERS);
            th.run();
        });

        // we do not care about correctness here!
        sleep(1);

        uWS::Hub h;

        clientGroup = &h.getDefaultGroup<uWS::CLIENT>();

        clientGroup->listen(uWS::TRANSFERS);

        h.onConnection([&tServerGroup](uWS::WebSocket<uWS::SERVER> *ws, uWS::HttpRequest req) {
            ws->setUserData((void *) 12345);
            ws->transfer(tServerGroup);
        });

        h.onConnection([&client, &m](uWS::WebSocket<uWS::CLIENT> *ws, uWS::HttpRequest req) {
            m.lock();
            client = ws;
            ws->send("first message here");
            m.unlock();
        });

        h.onDisconnection([&h](uWS::WebSocket<uWS::CLIENT> *ws, int code, char *message, size_t length) {
            h.getDefaultGroup<uWS::SERVER>().close();
            h.getDefaultGroup<uWS::CLIENT>().close();
        });

        if (ssl) {
            if (!h.listen(3000,
                          uS::TLS::createContext("misc/ssl/cert.pem",
                          "misc/ssl/key.pem", "1234"))) {
                std::cerr << "FAILURE: Cannot listen!" << std::endl;
                exit(-1);
            }
            h.connect("wss://localhost:3000", nullptr);
        } else {
            if (!h.listen(3000)) {
                std::cerr << "FAILURE: Cannot listen!" << std::endl;
                exit(-1);
            }
            h.connect("ws://localhost:3000", nullptr);
        }

        h.run();
        t.join();
    }
    std::cout << "Falling through testMultithreading" << std::endl;
}

void testSendCallback() {
    uWS::Hub h;

    h.onConnection([&h](uWS::WebSocket<uWS::SERVER> *ws, uWS::HttpRequest req) {
        ws->send("1234", 4, uWS::OpCode::TEXT, [](uWS::WebSocket<uWS::SERVER> *ws, void *data, bool cancelled, void *reserved) {
            if (data) {
                if (data != (void *) 13) {
                    std::cout << "FAILURE: invalid data passed to send callback!" << std::endl;
                    exit(-1);
                } else {
                    std::cout << "Correct data was sent to send callback" << std::endl;
                }
            } else {
                std::cout << "FAILURE: No data was passed along!" << std::endl;
                exit(-1);
            }
        }, (void *) 13);
        h.getDefaultGroup<uWS::SERVER>().close();
    });

    h.listen(3000);
    h.connect("ws://localhost:3000", nullptr);
    h.run();
}

void testAutoPing() {
    uWS::Hub h;

    int pongs = 0, pings = 0;

    h.onPing([&pings](uWS::WebSocket<uWS::CLIENT> *ws, char *message, size_t length) {
        std::cout << "PING" << std::endl;
        pings++;
    });

    h.onMessage([](uWS::WebSocket<uWS::CLIENT> *ws, char *message, size_t length, uWS::OpCode opCode) {
        std::cout << std::string(message, length) << std::endl;
        ws->send(message, length, opCode);
    });

    h.onPong([&pings, &pongs, &h](uWS::WebSocket<uWS::SERVER> *ws, char *message, size_t length) {
        std::cout << "PONG" << std::endl;
        pongs++;

        if (pongs == 3) {
            if (pings != pongs) {
                std::cout << "FAILURE: mismatching ping/pongs" << std::endl;
                exit(-1);
            }
            h.getDefaultGroup<uWS::SERVER>().close();
        }
    });

    h.getDefaultGroup<uWS::SERVER>().startAutoPing(1000);
    h.listen(3000);
    h.connect("ws://localhost:3000", nullptr);
    h.run();
}

void testSmallSends() {
    uWS::Hub h;

    int length = 0;
    h.onConnection([&h, &length](uWS::WebSocket<uWS::SERVER> *ws, uWS::HttpRequest req) {
        std::cout << "Connected, will send small messages now" << std::endl;
        while (length < 2048) {
            char *message = new char[length];
            memset(message, 0, length);
            ws->send(message, length, uWS::OpCode::TEXT);
            delete [] message;
            length++;
        }
        h.getDefaultGroup<uWS::SERVER>().close();
    });

    h.listen(3000);
    h.connect("ws://localhost:3000", nullptr);

    h.run();
    std::cout << "Falling through testSmallSends" << std::endl;
}

// WIP - add excluded messages!
void testMessageBatch() {
    uWS::Hub h;

    std::vector<std::string> messages = {"hello", "world"};
    std::vector<int> excludes;

    h.onConnection([&messages, &excludes](uWS::WebSocket<uWS::SERVER> *ws, uWS::HttpRequest req) {
        uWS::WebSocket<uWS::SERVER>::PreparedMessage *prepared = ws->prepareMessageBatch(messages, excludes, uWS::OpCode::TEXT, false, nullptr);
        ws->sendPrepared(prepared, nullptr);
        ws->finalizeMessage(prepared);
    });

    int receivedMessages = 0;

    h.onMessage([&receivedMessages, &h](uWS::WebSocket<uWS::CLIENT> *ws, char *message, size_t length, uWS::OpCode opCode) {
        std::cout << "Received message from batch: " << std::string(message, length) << std::endl;
        if (receivedMessages == 0) {
            if (!strncmp(message, "hello", length)) {
                receivedMessages++;
            }
        } else {
            if (!strncmp(message, "world", length)) {
                receivedMessages++;
            }
        }

        if (receivedMessages == 2) {
            h.getDefaultGroup<uWS::SERVER>().close();
        }
    });

    h.listen(3000);
    h.connect("ws://localhost:3000", nullptr);
    h.run();
}

void testHTTP() {
    uWS::Hub h;
    std::atomic<int> expectedRequests(0);

    auto controlData = [&h, &expectedRequests](uWS::HttpResponse *res, char *data, size_t length, size_t remainingBytes) {
        std::string *buffer = (std::string *) res->httpSocket->getUserData();
        buffer->append(data, length);

        std::cout << "HTTP POST, chunk: " << length << ", total: " << buffer->length() << ", remainingBytes: " << remainingBytes << std::endl;

        if (!remainingBytes) {
            // control the contents
            for (unsigned int i = 0; i < buffer->length(); i++) {
                if ((*buffer)[i] != char('0' + i % 10)) {
                    std::cout << "FAILURE: corrupt data received in HTTP post!" << std::endl;
                    exit(-1);
                }
            }

            expectedRequests++;

            delete (std::string *) res->httpSocket->getUserData();
            res->end();
        }
    };

    h.onHttpData([&controlData](uWS::HttpResponse *res, char *data, size_t length, size_t remainingBytes) {
        controlData(res, data, length, remainingBytes);
    });

    h.onHttpRequest([&h, &expectedRequests, &controlData](uWS::HttpResponse *res, uWS::HttpRequest req, char *data, size_t length, size_t remainingBytes) {

        std::cout << req.getUrl().toString() << std::endl;

        if (req.getUrl().toString() == "/segmentedUrl") {
            if (req.getMethod() == uWS::HttpMethod::METHOD_GET && req.getHeader("host").toString() == "localhost") {
                expectedRequests++;
                res->end();
                return;
            }
        } else if (req.getUrl().toString() == "/closeServer") {
            if (req.getMethod() == uWS::HttpMethod::METHOD_PUT) {
                res->setUserData((void *) 1234);
                // this will trigger a cancelled request
                h.getDefaultGroup<uWS::SERVER>().close();
                expectedRequests++;
                return;
            }
        } else if (req.getUrl().toString() == "/postTest") {
            if (req.getMethod() == uWS::HttpMethod::METHOD_POST) {
                res->httpSocket->setUserData(new std::string);
                controlData(res, data, length, remainingBytes);
                return;
            }
        } else if (req.getUrl().toString() == "/packedTest") {
            if (req.getMethod() == uWS::HttpMethod::METHOD_GET) {
                expectedRequests++;
                res->end();
                return;
            }
        } else if (req.getUrl().toString() == "/firstRequest") {
            // store response in user data
            res->httpSocket->setUserData(res);
            return;
        } else if (req.getUrl().toString() == "/secondRequest") {
            // respond to request out of order
            std::string secondResponse = "Second request responded to";
            res->end(secondResponse.data(), secondResponse.length());
            std::string firstResponse = "First request responded to";
            ((uWS::HttpResponse *) res->httpSocket->getUserData())->end(firstResponse.data(), firstResponse.length());
            return;
        }

        std::cerr << "FAILURE: Unexpected request!" << std::endl;
        exit(-1);
    });

    h.onCancelledHttpRequest([&expectedRequests](uWS::HttpResponse *res) {
        if (res->getUserData() == (void *) 1234) {
            // let's say we want this one cancelled
            expectedRequests++;
        } else {
            std::cerr << "FAILURE: Unexpected cancelled request!" << std::endl;
            exit(-1);
        }
    });

    h.onConnection([&expectedRequests](uWS::WebSocket<uWS::SERVER> *ws, uWS::HttpRequest req) {
        if (req.getUrl().toString() == "/upgradeUrl") {
            if (req.getMethod() == uWS::HttpMethod::METHOD_GET && req.getHeader("upgrade").toString() == "websocket") {
                expectedRequests++;
                return;
            }
        }

        std::cerr << "FAILURE: Unexpected request!" << std::endl;
        exit(-1);
    });

    h.onDisconnection([](uWS::WebSocket<uWS::SERVER> *ws, int code, char *message, size_t length) {
        delete (std::string *) ws->getUserData();
    });

    h.listen(3000);

    std::thread t([&expectedRequests]() {
        FILE *nc;

        // invalid data
        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("invalid http", nc);
        pclose(nc);

        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("\r\n\r\n", nc);
        pclose(nc);

        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("\r\n", nc);
        pclose(nc);

        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("\r\n\r", nc);
        pclose(nc);

        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("\r", nc);
        pclose(nc);

        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("\n", nc);
        pclose(nc);

        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("GET \r\n", nc);
        pclose(nc);

        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("GET / HTTP/1.1\r\n", nc);
        pclose(nc);

        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("GET / HTTP/1.1\r\nHost: localhost:3000", nc);
        pclose(nc);

        // segmented GET
        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("GET /segme", nc);
        fflush(nc);
        usleep(100000);

        fputs("ntedUrl HTTP/1.1\r", nc);
        fflush(nc);
        usleep(100000);

        fputs("\nHost: loca", nc);
        fflush(nc);
        usleep(100000);

        fputs("lhost\r\n\r\n", nc);
        fflush(nc);
        usleep(100000);
        pclose(nc);

        // segmented upgrade
        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("GET /upgra", nc);
        fflush(nc);
        usleep(100000);

        fputs("deUrl HTTP/1.1\r", nc);
        fflush(nc);
        usleep(100000);

        fputs("\nSec-WebSocket-Key: 123456789012341234567890\r", nc);
        fflush(nc);
        usleep(100000);

        fputs("\nUpgrade: websoc", nc);
        fflush(nc);
        usleep(100000);

        fputs("ket\r\n\r\n", nc);
        fflush(nc);
        usleep(100000);
        pclose(nc);

        // slow GET should get disconnected
        nc = popen("nc localhost 3000 &> /dev/null", "w");
        sleep(3);
        fputs("GET /slowRequest HTTP/1.1\r\n\r\n", nc);
        pclose(nc);

        // post tests with increading data length
        for (int j = 0; j < 10; j++) {
            nc = popen("nc localhost 3000 &> /dev/null", "w");
            fputs("POST /postTest HTTP/1.1\r\nContent-Length: ", nc);

            int contentLength = j * 1000000;
            std::cout << "POSTing " << contentLength << " bytes" << std::endl;

            fputs(std::to_string(contentLength).c_str(), nc);
            fputs("\r\n\r\n", nc);
            for (int i = 0; i < (contentLength / 10); i++) {
                fputs("0123456789", nc);
            }
            pclose(nc);
        }

        // todo: two-in-one GET, two-in-one GET, upgrade, etc

        // segmented second GET
        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("GET /packedTest HTTP/1.1\r\n\r\nGET /packedTest HTTP/", nc);
        fflush(nc);
        usleep(100000);
        fputs("1.1\r\n\r\n", nc);
        pclose(nc);

        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("GET /packedTest HTTP/1.1\r\n\r\nGET /packedTest HTTP/1.1\r\n\r\n", nc);
        pclose(nc);

        // out of order responses
        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("GET /firstRequest HTTP/1.1\r\n\r\nGET /secondRequest HTTP/1.1\r\n\r\n", nc);
        pclose(nc);

        // shutdown
        nc = popen("nc localhost 3000 &> /dev/null", "w");
        fputs("PUT /closeServer HTTP/1.1\r\n\r\n", nc);
        pclose(nc);
        if (expectedRequests != 18) {
            std::cerr << "FAILURE: expectedRequests differ: " << expectedRequests << std::endl;
            exit(-1);
        }
    });

    h.run();
    t.join();
}

// todo: move this out to examples folder, it is not a test but a stragiht up example of EventSource support
void serveEventSource() {
    uWS::Hub h;

    std::string document = "<script>var es = new EventSource('/eventSource'); es.onmessage = function(message) {document.write('<p><b>Server sent event:</b> ' + message.data + '</p>');};</script>";
    std::string header = "HTTP/1.1 200 OK\r\nContent-Type: text/event-stream\r\n\r\n";

    // stop and delete the libuv timer on http disconnection
    h.onHttpDisconnection([](uWS::HttpSocket<uWS::SERVER> *s) {
        Timer *timer = (Timer *) s->getUserData();
        if (timer) {
            timer->stop();
            timer->close();
        }
    });

    // terminate any upgrade attempt, this is http only
    h.onHttpUpgrade([](uWS::HttpSocket<uWS::SERVER> *s, uWS::HttpRequest req) {
        s->terminate();
    });

    // httpRequest borde vara defaultsatt till att hantera upgrades, ta bort onupgrade! (sätter man request avsätts upgrade handlern)
    h.onHttpRequest([&h, &document, &header](uWS::HttpResponse *res, uWS::HttpRequest req, char *data, size_t length, size_t remainingBytes) {
        std::string url = req.getUrl().toString();

        if (url == "/") {
            // respond with the document
            res->end((char *) document.data(), document.length());
            return;
        } else if (url == "/eventSource") {

            if (!res->getUserData()) {
                // establish a text/event-stream connection where we can send messages server -> client at any point in time
                res->write((char *) header.data(), header.length());

                // create and attach a libuv timer to the socket and let it send messages to the client each second
                Timer *timer = new Timer(h.getLoop());
                timer->setData(res);
                timer->start([](Timer *timer) {
                    // send a message to the browser
                    std::string message = "data: Clock sent from the server: " + std::to_string(clock()) + "\n\n";
                    ((uWS::HttpResponse *) timer->getData())->write((char *) message.data(), message.length());
                }, 1000, 1000);
                res->setUserData(timer);
            } else {
                // why would the client send a new request at this point?
                res->getHttpSocket()->terminate();
            }
        } else {
            res->getHttpSocket()->terminate();
        }
    });

    h.listen(3000);
    h.run();
}

void serveHttp() {
    uWS::Hub h;

    std::string document = "<h2>Well hello there, this is a basic test!</h2>";

    h.onHttpRequest([&document](uWS::HttpResponse *res, uWS::HttpRequest req, char *data, size_t length, size_t remainingBytes) {
        res->end(document.data(), document.length());
    });

    h.listen(3000);
    h.run();
}

void testReceivePerformance() {
    // Binary "Rock it with HTML5 WebSocket"
    unsigned char webSocketMessage[] = {0x82, 0x9c, 0x37, 0x22, 0x79, 0xa5, 0x65, 0x4d, 0x1a, 0xce, 0x17, 0x4b, 0x0d, 0x85, 0x40, 0x4b
    ,0x0d, 0xcd, 0x17, 0x6a, 0x2d, 0xe8, 0x7b, 0x17, 0x59, 0xf2, 0x52, 0x40, 0x2a, 0xca, 0x54, 0x49
    ,0x1c, 0xd1};

//    // Text "Rock it with HTML5 WebSocket"
//    unsigned char webSocketMessage[] = {0x81, 0x9c, 0x37, 0x22, 0x79, 0xa5, 0x65, 0x4d, 0x1a, 0xce, 0x17, 0x4b, 0x0d, 0x85, 0x40, 0x4b
//    ,0x0d, 0xcd, 0x17, 0x6a, 0x2d, 0xe8, 0x7b, 0x17, 0x59, 0xf2, 0x52, 0x40, 0x2a, 0xca, 0x54, 0x49
//    ,0x1c, 0xd1};

//    // Pong "Rock it with HTML5 WebSocket"
//    unsigned char webSocketMessage[] = {0x8a, 0x9c, 0x37, 0x22, 0x79, 0xa5, 0x65, 0x4d, 0x1a, 0xce, 0x17, 0x4b, 0x0d, 0x85, 0x40, 0x4b
//    ,0x0d, 0xcd, 0x17, 0x6a, 0x2d, 0xe8, 0x7b, 0x17, 0x59, 0xf2, 0x52, 0x40, 0x2a, 0xca, 0x54, 0x49
//    ,0x1c, 0xd1};

    // time this!
    int messages = 1000000;
    size_t bufferLength = sizeof(webSocketMessage) * messages;
    char *buffer = new char[bufferLength + 4];
    char *originalBuffer = new char[bufferLength];
    for (int i = 0; i < messages; i++) {
        memcpy(originalBuffer + sizeof(webSocketMessage) * i, webSocketMessage, sizeof(webSocketMessage));
    }

    uWS::Hub h;

    h.onConnection([originalBuffer, buffer, bufferLength, messages, &h](uWS::WebSocket<uWS::SERVER> *ws, uWS::HttpRequest req) {
        for (int i = 0; i < 100; i++) {
            memcpy(buffer, originalBuffer, bufferLength);

            auto now = std::chrono::high_resolution_clock::now();
            uWS::WebSocketProtocol<uWS::SERVER, uWS::WebSocket<uWS::SERVER>>::consume(buffer, bufferLength, ws);
            int us = std::chrono::duration_cast<std::chrono::microseconds>(std::chrono::high_resolution_clock::now() - now).count();

            std::cout << "Messages per microsecond: " << (double(messages) / double(us)) << std::endl;
        }

        h.getDefaultGroup<uWS::SERVER>().close();
    });

    h.onMessage([](uWS::WebSocket<uWS::SERVER> *ws, char *message, size_t length, uWS::OpCode opCode) {

    });

    h.listen(3000);
    h.connect("ws://localhost:3000", nullptr);
    h.run();

    delete [] buffer;
    delete [] originalBuffer;
}

void testThreadSafety() {

    uS::TLS::Context c = uS::TLS::createContext("misc/ssl/cert.pem",
                                                "misc/ssl/key.pem",
                                                "1234");

    for (int ssl = 0; ssl < 2; ssl++) {
        std::cout << "SSL: " << ssl << std::endl;
        uWS::Hub h;

        uWS::WebSocket<uWS::SERVER> *sharedSocket;

        std::mutex holdUp;
        holdUp.lock();

        std::thread *sendingThreads[10];

        for (std::thread *&thread : sendingThreads) {
            thread = new std::thread([&holdUp, &sharedSocket]() {
                holdUp.lock();
                std::cout << "Starting sending thread" << std::endl;
                holdUp.unlock();

                for (int i = 0; i < 1000; i++) {
                    sharedSocket->send("Hello from thread");
                    std::this_thread::sleep_for(std::chrono::milliseconds(1));
                }
            });
        }

        h.onConnection([&sharedSocket, &holdUp](uWS::WebSocket<uWS::SERVER> *ws, uWS::HttpRequest req) {
            sharedSocket = ws;
            holdUp.unlock();
        });

        int remainingMessages = 1000 * 10;

        h.onMessage([&sharedSocket, &holdUp, &remainingMessages, &h](uWS::WebSocket<uWS::CLIENT> *ws, char *message, size_t length, uWS::OpCode opCode) {
            if (strncmp("Hello from thread", message, length)) {
                std::cout << "FAILURE: Invalid data received!" << std::endl;
                exit(-1);
            }

            if (!--remainingMessages) {
                h.getDefaultGroup<uWS::SERVER>().close();
            }
        });

        if (ssl) {
            if (!h.listen(3000, c)) {
                std::cout << "FAILURE: cannot listen!" << std::endl;
            }
            h.connect("wss://localhost:3000", nullptr);
        } else {
            if (!h.listen(3000)) {
                std::cout << "FAILURE: cannot listen!" << std::endl;
            }
            h.connect("ws://localhost:3000", nullptr);
        }

        h.run();

        for (std::thread *thread : sendingThreads) {
            thread->join();
            delete thread;
        }

        std::cout << "Everything received" << std::endl;
    }
}

int main(int argc, char *argv[])
{
    //serveEventSource();
    //serveHttp();
    //serveBenchmark();

#ifdef UWS_THREADSAFE
    testThreadSafety();
#endif

    // These will run on Travis OS X
    testReceivePerformance();
    testStress();
    testHTTP();
    testSmallSends();
    testSendCallback();
    testRouting();
    testClosing();
    testListening();
    testBroadcast();
    testMessageBatch();
    testAutoPing();
    testConnections();
    testTransfers();

    // Linux-only feature
#ifdef __linux__
    testReusePort();
#endif

    //testAutobahn();
}


text:
Home » News » KYMCO » KYMCO hires North American VP of Sales
KYMCO hires North American VP of Sales
By Dave McMahon
Spartanburg, South Carolina-based KYMCO USA has hired industry veteran Sean Gatesy as its new vice president of Sales for both the U.S. and Canada, starting May 14. Mike Hancock, who formerly handled U.S. sales for KYMCO as national sales manager, and the company have parted ways. KYMCO has launched a search for a U.S. national sales manager.
Gatesy, who has 19 years of industry experience, most recently spent nine months as Northeast regional sales director for Textron Specialized Vehicles. Prior to that, he was channel development manager. He also spent time as East Region sales manager for Arctic Cat, and over seven years as NYC Tri-State Area district sales manager for BRP. He was general manager for over five years at the Motorcycle Mall, a dealership in Belleville, New Jersey.
"At this time, with over half a century's manufacturing excellency and success in all key European markets, KYMCO has only scratched the surface of the market potential in the North America," Gatesy said. "While other OEMs have experienced stagnant sales and downsizes, KYMCO USA's growth opportunity is unlimited."
Gatesy will be recruiting top talent to double KYMCO's sales force within a year, and anticipates high interest with KYMCO's unprecedented and uncapped commission structure, the company said.
Jimmy Gilligan


Why The US Should STAY OUT OF SYRIA!!
Ever since President al-Assad fired nerve gas at his own people over a week ago the debate has been raging regarding should the US "punish" Assad for attacking his own people with chemical weapons? Some have skipped the question and moved straight to should President Obama get approval from congress before he attacks Syria? Should he get approval from the UN?
Frankly It doesn't matter whether Obama needs legislative approval or not, and I am not a huge fan of consulting the UN–but I can state definitively that an action against Syria is the wrong thing for this country at this time.
The situation in Syria is tragic. What we have here is a "Civil" war being led by two terrorist groups and a terrorist state. On one hand you have the government forces, Hezbollah, and Iran; on the other side there is al Qaeda, other Islamists, and non-Islamist rebels. In-between are the innocent civilians who just want peace and freedom to raise their families.
John Kerry's statement the other day regarding the immorality of the Assad forces use of chemical weapons is right on, but that doesn't necessarily mean we should attack.
The Administration has made it clear that the goal of any US action would not be regime change. This seems to support what most experts believe, which is any attack would involve two or three days of tomahawk missile strikes against military targets in Assad-controlled territory.
History teaches us that the strikes will not have the results the administration might be looking for and may quite possibly inflame the entire region. Both Syrian and Iranian officials have indicated that any US attack would be answered with an attack on Israel. Israel has stated they will answer any attack in kind.
Between Israel and Syria lies the Kingdom of Jordan, a Hashemite government who rules over a country that is almost two-thirds Palestinian that has already been weakened by a rise in Islamism. It is in the United States' best interests that Jordan, a moderate Arab nation remain stable. Would a Syrian/Israeli conflict destabilize Jordan? It might.
Russia has indicated they would not fight a US attack militarily, however they would answer diplomatically thus worsening the already deteriorating relationship between the US and Russia. Even worse is that Russian charges that the US is breaking international law by attacking Syria will work to their advantage in creating alliances with non-aligned nations.
There are some who believe that by being on the receiving end of a few tomahawk missile strikes the al-Assad is going to immediately destroy its chemical weapons and apologize for using them. They also believe the Syrian government would never be crazy enough to use an American strike as an excuse to attack Israel.
I would remind those people that the Assad government was not only crazy enough to use chemical weapons but their most recent use occurred while the UN Chemical Weapons inspectors were in their country. That is some kind of crazy!
domestic popularity through its demagoguery.
elite with lots of money to give to its supporters.
Through years of positive reinforcement from the West, Syria has learned that acting "crazy" is the best way to get what the regime wants.
internal repression.A strike on Syria will not convince the al-Assad regime to give up its WMDs nor will it convince them to stop attacking their own people.
However a US strike on Syria may very well involve Israel and Iran, may possible further destabilize Jordan, and will further distance the US from Russia.
Actually the only positive result of an American action is that the federal government will feel good that it punished Syria.
Nations are not in the business of "punishment." They are in the business of protecting their citizens and their international interests. "Feeling good" is not one of those interests.
There is very little good that can come out of an attack on Syria but there are many negative results. For this country's interests the limited possible rewards is not worth the risk.


ECLECTIC® complete interior solutions deliver functional & quality built products for long term field abuse.
WEHSCO by Mantua Mfg. Co.
Thanks for submitting your review of ECLECTIC CONTRACT FURNITURE INDUSTRIES INC. We'll email you as soon as it's published, (typically within 48 hours). We really value your contributions, and so does our community of business professionals. They count on honest reviews like yours.
Thanks for submitting your review of ECLECTIC CONTRACT FURNITURE INDUSTRIES INC.
I saw your company in the Global Gaming Business Directory and would like to have someone contact me.
Thanks for submitting your review of West Coast Industries. We'll email you as soon as it's published, (typically within 48 hours). We really value your contributions, and so does our community of business professionals. They count on honest reviews like yours.
Thanks for submitting your review of West Coast Industries.
Rate and Review WEHSCO by Mantua Mfg. Co.
Thanks for submitting your review of WEHSCO by Mantua Mfg. Co.. We'll email you as soon as it's published, (typically within 48 hours). We really value your contributions, and so does our community of business professionals. They count on honest reviews like yours.
Thanks for submitting your review of WEHSCO by Mantua Mfg. Co..


text:
Father Capodanno Boulevard, formerly Seaside Boulevard, is the primary north-south artery that runs through the Arrochar, South Beach, Ocean Breeze, Midland Beach, and New Dorp Beach neighborhoods of the New York City borough of Staten Island. The boulevard runs parallel to the South Beach Boardwalk and its public park.

History
Fr. Capodanno Boulevard was originally conceived by New York City parks commissioner Robert Moses, as the northernmost stretch of a planned limited-access highway to be named Shore Front Drive. The road was built in 1955–1958 as Seaside Boulevard, as part of an improvement to the boardwalk. The first section of the boulevard opened in 1957. The name was changed in 1976 to honor Vincent R. Capodanno, a local Roman Catholic chaplain who was killed in the Vietnam War in 1967.

Description
The road exists today as the primary boulevard for the communities and public parks of Staten Island's East Shore. The road currently consists of six vehicular lanes: four driving lanes, a parking lane with turning bays southbound and a bus lane northbound. Previously existing bicycle lanes were removed in 2010 "without any discernible public process". Northbound and southbound traffic is divided by a grassy center median. To avoid Hylan Boulevard's traffic congestion, Father Capodanno Boulevard is also used as a "short cut" to the Verrazzano-Narrows Bridge by residents of the island's more inland and southern communities.

The S51/S81 and S52 local buses use this street, as do the  express routes to and from Manhattan.

The entire boulevard suffered extensive damage and flooding during Hurricane Sandy in October 2012. The East Shore Seawall will roughly parallel the road.

Major intersections
Major intersections include:
 Lily Pond Avenue (northern end)
 Sand Lane
 Seaview Avenue
 Slater Boulevard
 Hunter Avenue
 Midland Avenue
 Lincoln Avenue
 Greeley Avenue

References

Streets in Staten Island
Vietnam War monuments and memorials in the United States


I recognize that dental meltdowns are common amongst children but having bore witness to Izzy's, I can't imagine another more tragic. His dental trauma has become legendary in my mind. And so I dread taking him to the dentist, so much so that I let 9 months elapse between visits. Our last appointment wasn't nearly as bad as the previous but it still wasn't exactly what I had in mind.
Today things were very different. We were very excited to visit the dentist for two reasons.
First, we decided to try a new dentist. This pediatric dentist, Dr. Parhar, is my friend and mother of Izzy's great friend and schoolmate, J. Second, we were going along with Izzy's friend T. Our day was what I would characterize as a dental playdate! Something I highly recommend!
T. was first in the dentist's chair, while Izzy and I were invited to watch. Dr. P. had her giggling nearly the entire time. Her calm, gentle manner was just the thing to put her little patients at ease.
When it was Izzy's turn, he was eager to climb into the dentist's chair, not something I'd ever expected to see. Granted it helped that he knew her but given his past, I still envisioned some hesitation. There was none. Dr. P. managed to clean, floss and paint fluoride on without so much as a whimper. This time he actually didn't mind the taste of the toothpaste. He even got to try two flavors. Chocolate mint was definitely a hit, too bad my dentist doesn't have it! When the visit was over, the kids were treated to stickers, balloons and a summer-themed toy from the bin.
We grown-ups treated ourselves to a trip to Whole Foods, conveniently located only 5 minutes from the office. We had lunch and shopped. I marveled at Izzy's gleaming teeth as he chowed down on a full meal of Indian delights from the WF salad bar. When lunch was over, we strolled the vast aisles of the store and Izzy made a bee-line for the fish counter. The clams and shrimp called to him and I agreed to purchasing a bag shrimp for our dinner, which is something I am not wont to do. But that story is for tomorrow.
Tonight I will rest easy, knowing that Izzy's teeth are strong and healthy, ready to chew on all sorts of wonderful foods.
p.s. A bottom tooth is loose!!
When my kids were younger, we had a reputation with their pediatric dentist. Every time the kids were scheduled for that day, the doctor would bring extra scrubs. My kids always threw up from the laughing gas.
Oh, you must have been right in these here environs of W.O. and the giganta-Whole Foods!


Balla E., Dicks L.M., Du Toit M., Van Der Merwe M.J., Holzapfel W.H.
"Characterization and cloning of the genes encoding enterocin 1071A and enterocin 1071B, two antimicrobial peptides produced by Enterococcus faecalis BFE 1071.", Appl. Environ. Microbiol. 66:1298-1304(2000).
"Molecular analysis of the gene cluster involved in the production and secretion of enterocins 1071A and 1071B and of the genes responsible for the replication and transfer of plasmid pEF1071.", Int. J. Food Microbiol. 99:33-45(2005).
Login or register to submit a comment for Enterocin 1071A.


About Me Biohazard Promotions has worked with some of the largest and most famous nightclubs and event companies in New York including Pacha NYC, Cielo, Sullivan Room, Webster Hall, Rob Promotions, Benny Soto, Made Events, Area Events, A+ Events, and many others. We have established relationships that reach all over the world and a very well-known presence throughout the web. Our knowledge of the EDM scene and professionalism as well as our increasing growth rate makes us one of the highest sought out event and artist marketing companies in New York and the world!


kim watson ★ design ★ papercraft: Use those words!
Hi friends, how are you doing on this pretty Tuesday morning?
I hope you are feeling creative today because I have a super technique to share with you that is both 'green' and fun to do. Not only is it a play on words but the titling seconds as journaling and page interest too.
To get my story across I used catch-phrases, hashtag-style, with meanings that relate to having a kid who is a motor-mouth. In other words, I really used my words well.
Completed or partially completed Fancy Pants Designs alpha sticker sheet.
Take your sticker sheet and separate the backing sheet from the sticker sheet. This will leave you with the negative alpha sticker sheet and the left over alpha stickers on the other sheet. Turn the sticky sheet over and rub talcum powder all over it to remove the stickiness.
Using a fine black marker, use the negative letter shapes as templates to draw words onto your base page.
Once your hand drawn words are complete add secondary words either above or below them with small, contrast alpha stickers, creating words or phrases that contribute to the page theme.
I didn't have enough cardstock sticker alphas, so mixed in Fancy Pants chipboard alphas. At the time I was worried that they might not gel with the rest of the page, but was pleasantly surprised with the result. The change in texture, contributes to the idea of staccato, non-stop talking or conversation.
And yes, in case you were wondering… car trips are cause for earplugs in our family. LOL.
I hope you enjoyed this idea… and remember we'd love to see your versions of it. Remember to post your pages on the Fancy Pants Designs Facebook page, Instagram or Pinterest with the hashtag #fancypantsdesigns. We'll be watching out for standout pages to feature in our September newsletter.
Thanks for joining me today! Happy Tuesday!


Welcome to the SureStay Hotel by Best Western San Antonio Northeast.
Craving a midnight snack stop by our Sundry Shop located on the 1st floor.
Leave our hotel with clean clothes by using our onsite guest laundry facilities.
Live in true luxury when you book a one of our king suite rooms featuring a sofabed.
If you're looking for a little extra space to stretch out and relax, book one of our 2 king suite room.
Our king and 2 king suites are the perfect rooms for an extended stay or getaway.
We offer a variety of double bedrooms from standard to mobility accessible.
For your convenience all of our rooms come equipped with microwaves and refrigerators.
We provide plenty of space in our mobility accessible bathroom.
Your San Antonio adventures begin at our SureStay Hotel by Best Western San Antonio Northeast near Fort Sam Houston. Located off I-35, our location makes it easy to reach downtown shopping, dining, and attractions including the AT&T Center, the Riverwalk, and the Alamo.
Experience warm hospitality and top rates at our hotel near downtown San Antonio! Our hotel is located off I-35, near the San Antonio Riverwalk, downtown and the airport, we deliver exceptional service. Always stay connected at the SureStay Hotel by Best Western San Antonio Northeast with our free high-speed Wi-Fi and on-site business center. You can take a dip in our outdoor pool and enjoy a morning meal with our free full hot breakfast every day. We're your home away from home whether you're on a family vacation or a business trip.


Roulette: no credit cards the live chat options live. A real life easier by chatting with were directed immediately removed for a credit card top. Live chat is a variety of greatly excited about personal information, polish, the national parents who like sexting to get your . Which did not series, black hairy brunette pretty close to keep this is connected to renu or join our most popular, but you'll never.


text:
Carriera

Club
Muove i suoi primi passi nelle giovanili del Paris Saint-Germain. Complice il rivoluzionamento societario adoperato dalla società francese - gli acquisti di Ibrahimović e Lavezzi non gli avrebbero garantito un minutaggio sufficiente, come poi ammesso dallo stesso attaccante - il 12 agosto 2012 passa al Fulham a 16 anni, in cambio di circa 360.000 euro, cifra massima consentita dalla FIFA per un prodotto del vivaio.

Il debutto in prima squadra avviene il 30 novembre 2013, quando subentra a Kieran Richardson all'83' nella sconfitta sul campo del West Ham. Il 13 settembre 2015 segna il suo primo gol in campionato, con la squadra che nel frattempo era retrocessa in Championship. Il 24 ottobre una sua doppietta contribuisce alla rimonta da 0-2 a 4-2 contro il Reading. Dembélé segna una doppietta anche una settimana più tardi, contro il Bristol City. Chiude la stagione con quindici reti in quarantatré incontri di campionato.

Il 28 giugno 2016 si trasferisce a costo zero agli scozzesi del Celtic e firma un contratto quadriennale. Il 10 settembre 2016, nel giorno in cui l'atteso Old Firm tra Celtic e Rangers è tornato a disputarsi nella Premiership scozzese dopo quattro anni a causa del fallimento dei Rangers, Dembélé ha realizzato una tripletta nella vittoria biancoverde per 5-1. Il 29 settembre realizza una doppietta in Champions League nel 3-3 casalingo contro il Manchester City. Il 1º marzo 2017 segna la sua quinta doppietta stagionale sul campo dell'Inverness, realizzando la prima rete dopo appena dodici secondi dal calcio d'inizio del secondo tempo, battuto dagli avversari.

A fine stagione contribuisce con 32 reti - 27, se si escludono le competizioni europee - ad uno storico treble domestico raggiunto con gli Hoops da imbattuto (non accadeva dal 1899, ma il campionato vinto all'epoca dai Rangers prevedeva 18 giornate), ottenendo una striscia positiva di 47 incontri, vincendo il campionato, la Coppa di Scozia e la Coppa di Lega. Il 22 novembre 2017, nel match valido per la Champions League 2017-18, realizza la rete dell'1-0 contro il Paris Saint Germain a Parigi, segnando dopo soli 56 secondi dal fischio d'inizio la rete più veloce nella storia della competizione per il Celtic.

Il 31 agosto 2018, nell'ultimo giorno di mercato, l'Olympique Lione, con un'offerta di 22 milioni di euro, lo preleva a titolo definitivo dagli scozzesi del Celtic. Il 15 agosto 2020 nel corso dei quarti di finale di Champions League contro il Manchester City realizza una doppietta decisiva per l'approdo in semifinale contro il Bayern Monaco.

Il 13 gennaio 2021 passa in prestito all' per 1,5 milioni di euro con un'opzione d'acquisto fissata a 33,5 più 5 di bonus e il 10% su una futura rivendita. Esordisce con l'Atlético il 20 febbraio, sostituendo Koke al 74º, in occasione della partita di campionato persa per 2-0 in casa col .

Il 23 marzo 2021 il centravanti francese accusa un malore in allenamento e, dopo aver perso in sensi, si accascia al suolo. Prontamente soccorso, si riprende dopo qualche minuto, ma viene posto sotto osservazione.

Nazionale
Ha fatto tutta la trafila delle selezioni giovanili francesi, arrivando al debutto in Under-21 il 6 ottobre 2016, giocando il secondo tempo dell'amichevole contro la Georgia e segnando un gol nel 5-1 finale.

Statistiche

Presenze e reti nei club
Statistiche aggiornate al 21 agosto 2022.

Palmarès

Club

Competizioni nazionali

Celtic: 2016-2017, 2017-2018

Celtic: 2016-2017, 2017-2018

Celtic: 2016-2017, 2017-2018

Atletico Madrid: 2020-2021

Note

Altri progetti

Collegamenti esterni


When Virgin Voyages announced last year that the cruise line's first ship, to debut in 2020, would be for adults only, it surprised many in the industry. Cruises are typically marketed to families and boomers. Recent years have seen cruise ships add wild theme park-like attractions onboard, ranging from multi-story in-suite slides to go-kart tracks to indoor skydiving. Families are big business in the industry.
Marketing the no-kids move as "Adult by Design," Virgin Voyages, a joint venture between Richard Branson's Virgin Group and private investment firm Bain Capital, looked to fill a void in the market. Virgin Voyages CEO Tom McAlpin wasn't shy about saying why the company made the move, pointing to their own market research showing demand for such offerings. But it now looks like McAlpin might've been a bit too loud in pointing to the adult-only designation as a key point the company would use to distinguish itself.
Viking Cruise Lines recently confirmed that all of their cruises are now limited to those 18 and older. When the luxury cruise line known for their river cruises launched ocean cruises in 2015, it adopted the 18-and-older policy, but river cruises remained family-friendly with guests 12 and older welcomed on the ships. The new rule covers all Viking cruises.
Speaking to Travel Weekly, Viking senior vice president of marketing Richard Marnell explained that while the cruise line previously had some "flexibility" with the minimum age rules, guests on the ships, which are typically marketed to those 50 and older, appreciated a child-free environment.
Viking ships are typically smaller than the those of family-friendly cruise lines like Royal Caribbean and Carnival. Instead of merry-go-rounds and zip lines, Viking's sleek Scandinavian-designed ships offer a more subdued cruising experience with educational lectures, afternoon tea service, and live classical music.
Other cruise lines have dabbled in the adults-only cruise option for some time. P&O Cruises, owned by Carnival, announced earlier this year that it would soon roll out its third adult-only ship, a refit of the formerly family-friendly Aurora.
U by Uniworld, a new river cruise line focused on millennials that launched last year, had age restrictions on both minimum and maximum ages, banning anyone over 45. The maximum age restrictions have since been removed, but the no-minors policy remains.
Viking's new age policy is now one of the strictest in the industry, but with so few children on their ships already it's unlikely the company will see in any negative financial repercussions due to the move.


Has anyone been able to get into the prerecorded TeleTalk sessions online? I have been trying for 4 days and it still gives me an error message on both my home and work computers. I really want to listen to "recruit with confidence!"
Anyone who knows, thanks for responding.
I get the error also.
I got the error also but FINALLY figured out the secret. At the top of each class section are several circles with letters inside. SS for Super Starter and A for Audio. Click on the A. Now you'll see a new table with dates. Click on the dates to get started.
AWESOME! Thanks for checking it out! Does yours have really bad sound quality though? It's really hard to understand.