text:
<!DOCTYPE html>

<meta name="viewport" content="width=device-width, initial-scale=1">
<title> FAQs </title>

      D U K E   U N I V E R S I T Y
      RSVP
      f a q s
      s c h e d u l e
      s p e a k e r s
      a b o u t

FAQs

What is the Spring Business Conference?

The Spring Business Conference (SBC) features addresses by globally-recognized business leaders from various industries.

Where is the conference?

It is located at Geneen Auditorium in the Fuqua School of Business on Duke University West Campus.

100 Fuqua Drive, Durham, NC 27708

When is it?

 February 15, 2019 from 3pm to 6:30pm

Who is invited?

 Spring Business Conference (SBC) is free and open to all.

Business Oriented Women Spring Business Conference

    <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css">


text:
default[:celery][:install_type] = 'pip' # 'pip', 'source' & 'development' are the options
default[:celery][:version]      = nil # leave as nil for latest when using pip or provide a version for pip. Mandatory for install_type source

# Source install bits
default[:celery][:source][:extension] = 'tar.gz'
default[:celery][:source][:url]       = 'http://pypi.python.org/packages/source/c/celery'
default[:celery][:source][:checksum]  = nil # Mandatory for install_type source use shasum -a 256 celery-version.tar.gz to generate

# Development install
default[:celery][:development][:repository] = 'git://github.com/celery/celery.git'
default[:celery][:development][:reference]  = 'master'

# Worker install
default[:celery][:worker][:install_location] = nil
default[:celery][:worker][:repository]       = nil
default[:celery][:worker][:reference]        = 'master'

redpajama_set_name: RedPajamaGithub


text:
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical">

    <Button
        android:id="@+id/viewbindingfragment_button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content" />

</LinearLayout>


text:
import {ExpressionNode} from "../../nodes";
import {CurrentScope} from "../_current_scope";
import * as Expressions from "../../2_statements/expressions";
import {Source} from "./source";

export class RaiseWith {
  public runSyntax(node: ExpressionNode, scope: CurrentScope, filename: string) {
    for (const f of node.findDirectExpressions(Expressions.Source)) {
      new Source().runSyntax(f, scope, filename);
    }
  }
}


text:
<head>
  <link href="http://gmpg.org/xfn/11" rel="profile">
  <meta charset='utf-8'>
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta http-equiv="content-type" content="text/html; charset=utf-8">
  <!-- Enable responsiveness on mobile devices-->
  <meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1">

  <title>
    {% if page.title == "Home" %}
      {{ site.title }}
    {% else %}
      {{ site.title }} · {{ page.title }}
    {% endif %}
  </title>

  <!-- CSS -->
  {% stylesheet main.css %}

  <link href='https://fonts.googleapis.com/css?family=Roboto+Slab' rel='stylesheet' type='text/css'>

  <!-- RSS -->
  <link rel="alternate" type="application/rss+xml" title="RSS" href="/atom.xml">
</head>


text:
An esoteric programming language designed to contain as few instructions as
possible.

## Types

Macaroni has two types:

- Numbers, which are represented as 64-bit floating point internally.

- Arrays, which can contain other arrays or numbers.

However, it also has:

- "Strings," which are just arrays of numbers. The only place that Macaroni
  distinguishes between "strings" and arrays is in the I/O operators (`print`
  and `read`) and base operators (`tobase` and `frombase`).

- Some operators accept labels and expect them to set the `_` variable before
  returning. These are used as a primitive form of "blocks" or "subroutines."

## Operators

Macaroni has all of 25 operators.

### Number operators

- `nn` -> `n`: add
- `nn` -> `n`: multiply
- `n` -> `n`: floor
- `nn` -> `n`: pow
- `nn` -> `a`: tobase (\*returns an array-"string")

### Array operators

- `al` -> `a`: sort
- `aa` -> `a`: concat
- `an` -> `a`: each (a la Ruby `each_cons`, `each_slice` if arg. negative)
- `al` -> `a`: map
- `al` -> `a`: index (indeces)
- `annn` -> `a`: slice (a la Python `a[b:c:d]`)
- `a` -> `n`: length
- `a` -> `a`: transpose
- `an` -> `a`: flatten (0 = completely flatten)
- `an` -> `n`: frombase (\*for array-"strings" only)

### Other operators

- `*` -> `a`: wrap (in array)
- `a` -> `*`: unwrap
- `a` -> `-`: print
- `-` -> `a`: read (a single line, from STDIN)
- `-` -> `n`: rand (`[0,1)`)
- `-` -> `n`: time
- `v*` -> `-`: set
- `l` -> `-`: label
- `l` -> `-`: goto
- `-` -> `-`: return

## Syntax

The syntax of Macaroni is similar to many other languages, in that operators are called in *prefix notation*. In prefix notation, the name of the operator comes first, then the arguments. For example, `func(arg1, arg2)`.

However, the way Macaroni calls operators is slightly more unique. Each operator has a defined *arity*, which is simply the number of arguments it expects. This eliminates the need for parentheses. So, instead of saying `add(1, mult(2, 3))`, you would just say `add 1 mult 2 3`.

Since each operator has its own arity, there is no ambiguity with this syntax, and a simple recursive parser can be used.

## Common operations / combinations

Since Macaroni only has 25 operators, naturally there are tons of them that
have been left out. Here are some implementations of common functions that you
would expect to find in other languages.

- Absolute value of `x`

        map slice " " 0 x 1 a return
        label a set x multiply x -1 return

    A cleverer version that squares and then square roots the number:

        pow pow x 2 pow 2 -1

- `x` modulo `y` (using [a formula found on Wikipedia](https://en.wikipedia.org/wiki/Floor_and_ceiling_functions#Mod_operator))

        add x multiply -1 multiply y floor multiply x pow y -1

- A "while loop" ("calls" `func` while `x` is equal to `0`)

        label loop
            map
                map slice " " x add x 1 1 func
                loop
        return

        label func <stuff> return

## Why "macaroni"?

Macaroni's control flow is done entirely through `goto`s. The name "Macaroni"
is simply a spin-off of the aptly-named ["spaghetti
code."](https://en.wikipedia.org/wiki/Spaghetti_code)

## Contributing / credits

If you would like to contribute to Macaroni or suggest ideas, feel free to
either open an issue / pull request here on Github or ping me `@Doorknob` in
[The Nineteenth
Byte](http://chat.stackexchange.com/rooms/240/the-nineteenth-byte), the Stack
Exchange chatroom for [PPCG](http://codegolf.stackexchange.com).

*Huge* thanks to [@BlacklightShining](https://github.com/BlacklightShining) for
tons of help with implementing the language and spending their time to save
waaaay more of mine (while teaching me lots and lots about how Rust works in
the process). :)

Also, thanks to the `#rust` IRC channel for being awesome as always.


text:
<?php

namespace TLH\ContactBundle\Services;

use Symfony\Component\HttpFoundation\RequestStack;
use Twig\Environment;

class Messager implements MessagerInterface
{
    /**
     * @var RequestStack
     */
    private $requestStack;

    /**
     * @var Environment
     */
    private $templating;

    /**
     * @var \Swift_Mailer
     */
    private $mailer;

    /**
     * @var array
     */
    private $parameters;

    /**
     * Messager constructor.
     */
    public function __construct(Environment $templating, \Swift_Mailer $mailer, RequestStack $requestStack)
    {
        $this->templating = $templating;
        $this->requestStack = $requestStack;
        $this->mailer = $mailer;
    }

    /**
     * @param array $parameters
     *
     * @return Messager
     */
    public function setParameters($parameters)
    {
        $this->parameters = $parameters;
        return $this;
    }

    /**
     * @param string $parameter
     *
     * @return mixed|null
     */
    public function getParameter($parameter)
    {
        $values = explode(".", $parameter);

        $parameter = $this->parameters;
        while ($key = array_shift($values)) {
            if (!isset($parameter[$key])) {
                unset($parameter);
                break;
            }
            $parameter = $parameter[$key];
        }
        return (isset($parameter)) ? $parameter : null;
    }

    /**
     * @inheritDoc
     */
    public function sendConfirmationEmailMessage($contact, $template)
    {
        $this->sendEmailMessage(
            $this->renderTemplate($contact, $template),
            $this->getParameter('confirmation.from_email.address'),
            $this->getParameter('recipient_address')
        );
    }

    /**
     * @inheritDoc
     */
    public function sendInformationEmailMessage($contact, $template)
    {
        $this->sendEmailMessage(
            $this->renderTemplate($contact, $template),
            $this->getParameter('information.from_email.address'),
            $this->getParameter('recipient_address')
        );
    }

    /**
     * @param string $renderedTemplate
     * @param string $fromEmail
     * @param string $toEmail
     */
    protected function sendEmailMessage($renderedTemplate, $fromEmail, $toEmail)
    {
        // Render the email, use the first line as the subject, and the rest as the body
        $renderedLines = explode("\n", trim($renderedTemplate));
        $subject = $renderedLines[0];
        $body = implode("\n", array_slice($renderedLines, 1));

        $message = $this->mailer->createMessage();
        $message
            ->setSubject($subject)
            ->setFrom($fromEmail)
            ->setTo($toEmail)
            ->setBody($body);

        $this->mailer->send($message);
    }

    /**
     * @param $contact
     * @param string $template
     * @return string
     */
    private function renderTemplate($contact, $template)
    {
        $request = $this->requestStack->getCurrentRequest();
        $url      = $request->getScheme() . '://' . $request->getHttpHost() . $request->getBasePath();
        $rendered = $this->templating->render(
            $template,
            array(
                'website' => $url,
                'contact' => $contact
            )
        );

        return $rendered;
    }
}


text:
DIR=`pwd`
rm -fr silicon;
git clone https://github.com/matt-42/silicon.git
cd silicon;
CXX=/usr/bin/g++-4.9 ./install.sh $IROOT

# Install microhttpd
cd $DIR
fw_get http://mirror.ibcp.fr/pub/gnu/libmicrohttpd/libmicrohttpd-0.9.39.tar.gz
fw_untar libmicrohttpd-0.9.39.tar.gz
cd libmicrohttpd-0.9.39
./configure --prefix=$IROOT
make install

cd $TROOT
mkdir -p build
cd build; cmake .. -DCMAKE_CXX_COMPILER=g++-4.9; make silicon_tpc_mysql; make silicon_epoll_mysql


text:
class PagesController < ApplicationController
  def map
    @overlay = (params[:overlay] || 'sessions').inquiry
  end
end


text:
<ivy-module version="1.0">
	<info organisation="myorg"
	       module="mymodule"
	/>
	<publications>
		<artifact />
		<artifact name="myartifact" />
		<artifact type="dll" />
	</publications>
</ivy-module>


text:
:- module(check_non_mutually_exclusive, []).

:- use_module(library(apply)).
:- use_module(library(option)).
:- use_module(library(lists)).
:- use_module(library(ordsets)).
:- use_module(library(pairs)).
:- use_module(library(checkers/checker)).
:- use_module(library(check), []).
:- use_module(library(clambda)).
:- use_module(library(normalize_head)).
:- use_module(library(location_utils)).
:- use_module(library(option_utils)).
:- use_module(library(referenced_by)).
:- use_module(library(from_utils)).

:- multifile
    prolog:message//1,
    mutually_exclusive_predicate/2,
    mutually_exclusive_predicate_key/3.

mutually_exclusive_predicate(MH) :-
    strip_module(MH, M, H),
    mutually_exclusive_predicate(H, M).

mutually_exclusive_predicate(check(_, _, _), checker).
mutually_exclusive_predicate_key(check(K, _, _), checker, K).

checker:check(non_mutually_exclusive, Result, Options) :-
    option_module_files(Options, MFileD),
    option(predicate(Ref), Options, Ref),
    findall(Pairs, check_non_mutually_exclusive(MFileD, Ref, Pairs), Result).

check_non_mutually_exclusive(MFileD, Ref, warning-(Ref-LocIdx)) :-
    normalize_head(Ref, MH),
    mutually_exclusive_predicate(MH),
    collect_non_mutually_exclusive(MFileD, MH, LocIdxL),
    member(LocIdx, LocIdxL).

cleanup_redundant_groups([], _, []).
cleanup_redundant_groups([Key-Clause-ClauseNME|ClauseKeyU], ClauseKeyI, ClauseKeyR) :-
    ( \+ ( member(Key2-Clause2-ClauseNME2, ClauseKeyU),
           subset([Key-Clause|ClauseNME], [Key2-Clause2|ClauseNME2]),
           \+subset([Key2-Clause2|ClauseNME2], [Key-Clause|ClauseNME])
         ),
      \+ ( member(Key2-Clause2-ClauseNME2, ClauseKeyI),
           subset([Key-Clause|ClauseNME], [Key2-Clause2|ClauseNME2])
         )
    ->ClauseKeyR=[Key-Clause-ClauseNME|ClauseKeyR2],
      ClauseKeyI2=[Key-Clause-ClauseNME|ClauseKeyI]
    ; ClauseKeyR=ClauseKeyR2,
      ClauseKeyI2=ClauseKeyI
    ),
    cleanup_redundant_groups(ClauseKeyU, ClauseKeyI2, ClauseKeyR2).

:- meta_predicate collect_non_mutually_exclusive(+, 0, -).

collect_non_mutually_exclusive(MFileD, MH, LocPL) :-
    strip_module(MH, M, H),
    get_dict(M, MFileD, FileD),
    findall(I-(Key-Clause),
            ( clause(MH, _, Clause),
              nth_clause(MH, I, Clause),
              From = clause(Clause),
              from_to_file(From, File),
              get_dict(File, FileD, _),
              ( mutually_exclusive_predicate_key(H, M, Key)
              ->true
              ; Key = MH
              )
            ),
            ClauseKeyU),
    ClauseKeyU \= [],
    list_to_ord_set(ClauseKeyU, ClauseKeyL),
    findall(Key-Clause-ClauseNME,
            [Clause, Key, ClauseNME, ClauseKeyL] +\
            ( select(_-(Key-Clause), ClauseKeyL, ClauseKeyS),
              exclude([Key] +\ (_-(SKey-_)) ^ (SKey\=Key), ClauseKeyS, ClauseKeyNME),
              ClauseKeyNME \= [],
              pairs_values(ClauseKeyNME, ClauseNME)
            ),
            ClausePR),
    cleanup_redundant_groups(ClausePR, [], ClausePL),
    maplist(\ (Key1-Clause1-ClauseNME1)^((Loc1-Idx1/Key1)/LocL)
           ^( nth_clause(_, Idx1, Clause1),
              from_location(clause(Clause1), Loc1),
              maplist(\ (Key2-Clause2)^(Loc2-Idx2/Key2)
                     ^( nth_clause(_, Idx2, Clause2),
                        from_location(clause(Clause2), Loc2)
                      ),
                      ClauseNME1,
                      LocU),
              sort(LocU, LocL)
            ), ClausePL, LocPU),
    sort(LocPU, LocPL).

prolog:message(acheck(non_mutually_exclusive)) -->
    ['Non Mutually Exclusive Predicates',nl,
     '---------------------------------',nl,
     'The predicates below are marked as mutually_exclusive, but they have', nl,
     'non mutually exclusive clauses. You can resolve the ambiguity unifying', nl,
     'the non mutual exclusive clauses or changing the specification of such', nl,
     'predicates.', nl, nl].
prolog:message(acheck(non_mutually_exclusive, PI-LocCIs)) -->
    check:predicate(PI),
    [' has non mutually exclusive clauses:', nl],
    foldl(group_non_mut_ex, LocCIs).

locindex_index(_-I/_, I).

locindex_loccl(Loc-I/K, Loc/[' clause ~w'-[I, K]]).

group_non_mut_ex((Loc-Idx/Key)/LocIdxL) -->
    {maplist(locindex_index, LocIdxL, Idxs)},
    {maplist(locindex_loccl, LocIdxL, LCIs)},
    Loc, ['Clause ~w (key ~w) match with clauses ~w at'-[Idx, Key, Idxs], nl],
    referenced_by(LCIs).


text:
package org.ldp4j.server.controller;

public final class EndpointControllerFactory {

	private EndpointControllerFactory() {
	}

	public static EndpointController newController() {
		return new DefaultEndpointController();
	}

}