text:
"""Graph6

Read and write graphs in graph6 format.

Format
------

"graph6 and sparse6 are formats for storing undirected graphs in a
compact manner, using only printable ASCII characters. Files in these
formats have text type and contain one line per graph."

See http://cs.anu.edu.au/~bdm/data/formats.txt for details.
"""
# Original author: D. Eppstein, UC Irvine, August 12, 2003.
# The original code at http://www.ics.uci.edu/~eppstein/PADS/ is public domain.
#    Copyright (C) 2004-2013 by
#    Aric Hagberg <hagberg@lanl.gov>
#    Dan Schult <dschult@colgate.edu>
#    Pieter Swart <swart@lanl.gov>
#    Tomas Gavenciak <gavento@ucw.cz>
#    All rights reserved.
#    BSD license.
import networkx as nx
from networkx.exception import NetworkXError
from networkx.utils import open_file, not_implemented_for
__author__ = """\n""".join(['Tomas Gavenciak <gavento@ucw.cz>',
                            'Aric Hagberg <aric.hagberg@lanl.gov'])
__all__ = ['read_graph6', 'parse_graph6', 'generate_graph6', 'write_graph6']

def parse_graph6(string):
    """Read a simple undirected graph in graph6 format from string.

    Parameters
    ----------
    string : string
       Data in graph6 format

    Returns
    -------
    G : Graph

    Raises
    ------
    NetworkXError
        If the string is unable to be parsed in graph6 format

    Examples
    --------
    >>> G = nx.parse_graph6('A_')
    >>> sorted(G.edges())
    [(0, 1)]

    See Also
    --------
    generate_graph6, read_graph6, write_graph6

    References
    ----------
    Graph6 specification:
    http://cs.anu.edu.au/~bdm/data/formats.txt for details.
    """
    def bits():
        """Return sequence of individual bits from 6-bit-per-value
        list of data values."""
        for d in data:
            for i in [5,4,3,2,1,0]:
                yield (d>>i)&1

    if string.startswith('>>graph6<<'):
        string = string[10:]
    data = graph6_to_data(string)
    n, data = data_to_n(data)
    nd = (n*(n-1)//2 + 5) // 6
    if len(data) != nd:
        raise NetworkXError(\
            'Expected %d bits but got %d in graph6' % (n*(n-1)//2, len(data)*6))

    G=nx.Graph()
    G.add_nodes_from(range(n))
    for (i,j),b in zip([(i,j) for j in range(1,n) for i in range(j)], bits()):
        if b:
            G.add_edge(i,j)

    return G

@open_file(0,mode='rt')
def read_graph6(path):
    """Read simple undirected graphs in graph6 format from path.

    Parameters
    ----------
    path : file or string
       File or filename to write.

    Returns
    -------
    G : Graph or list of Graphs
       If the file contains multiple lines then a list of graphs is returned

    Raises
    ------
    NetworkXError
        If the string is unable to be parsed in graph6 format

    Examples
    --------
    >>> nx.write_graph6(nx.Graph([(0,1)]), 'test.g6')
    >>> G = nx.read_graph6('test.g6')
    >>> sorted(G.edges())
    [(0, 1)]

    See Also
    --------
    generate_graph6, parse_graph6, write_graph6

    References
    ----------
    Graph6 specification:
    http://cs.anu.edu.au/~bdm/data/formats.txt for details.
    """
    glist = []
    for line in path:
        line = line.strip()
        if not len(line):
            continue
        glist.append(parse_graph6(line))
    if len(glist) == 1:
        return glist[0]
    else:
        return glist

@not_implemented_for('directed','multigraph')
def generate_graph6(G, nodes = None, header=True):
    """Generate graph6 format string from a simple undirected graph.

    Parameters
    ----------
    G : Graph (undirected)

    nodes: list or iterable
       Nodes are labeled 0...n-1 in the order provided.  If None the ordering
       given by G.nodes() is used.

    header: bool
       If True add '>>graph6<<' string to head of data

    Returns
    -------
    s : string
       String in graph6 format

    Raises
    ------
    NetworkXError
        If the graph is directed or has parallel edges

    Examples
    --------
    >>> G = nx.Graph([(0, 1)])
    >>> nx.generate_graph6(G)
    '>>graph6<<A_'

    See Also
    --------
    read_graph6, parse_graph6, write_graph6

    Notes
    -----
    The format does not support edge or node labels, parallel edges or
    self loops.  If self loops are present they are silently ignored.

    References
    ----------
    Graph6 specification:
    http://cs.anu.edu.au/~bdm/data/formats.txt for details.
    """
    if nodes is not None:
        ns = list(nodes)
    else:
        ns = list(G)

    def bits():
        for (i,j) in [(i,j) for j in range(1,n) for i in range(j)]:
            yield G.has_edge(ns[i],ns[j])

    n = G.order()
    data = n_to_data(n)
    d = 0
    flush = False
    for i, b in zip(range(n * n), bits()):
        d |= b << (5 - (i % 6))
        flush = True
        if i % 6 == 5:
            data.append(d)
            d = 0
            flush = False
    if flush:
        data.append(d)

    string_data =  data_to_graph6(data)
    if header:
        string_data  =  '>>graph6<<' + string_data
    return string_data

@open_file(1, mode='wt')
def write_graph6(G, path, nodes = None, header=True):
    """Write a simple undirected graph to path in graph6 format.

    Parameters
    ----------
    G : Graph (undirected)

    path : file or string
       File or filename to write.

    nodes: list or iterable
       Nodes are labeled 0...n-1 in the order provided.  If None the ordering
       given by G.nodes() is used.

    header: bool
       If True add '>>graph6<<' string to head of data

    Raises
    ------
    NetworkXError
        If the graph is directed or has parallel edges

    Examples
    --------
    >>> G = nx.Graph([(0, 1)])
    >>> nx.write_graph6(G, 'test.g6')

    See Also
    --------
    generate_graph6, parse_graph6, read_graph6

    Notes
    -----
    The format does not support edge or node labels, parallel edges or
    self loops.  If self loops are present they are silently ignored.

    References
    ----------
    Graph6 specification:
    http://cs.anu.edu.au/~bdm/data/formats.txt for details.
    """
    path.write(generate_graph6(G, nodes=nodes, header=header))
    path.write('\n')

# helper functions

def graph6_to_data(string):
    """Convert graph6 character sequence to 6-bit integers."""
    v = [ord(c)-63 for c in string]
    if len(v) > 0 and (min(v) < 0 or max(v) > 63):
        return None
    return v

def data_to_graph6(data):
    """Convert 6-bit integer sequence to graph6 character sequence."""
    if len(data) > 0 and (min(data) < 0 or max(data) > 63):
        raise NetworkXError("graph6 data units must be within 0..63")
    return ''.join([chr(d+63) for d in data])

def data_to_n(data):
    """Read initial one-, four- or eight-unit value from graph6
    integer sequence.

    Return (value, rest of seq.)"""
    if data[0] <= 62:
        return data[0], data[1:]
    if data[1] <= 62:
        return (data[1]<<12) + (data[2]<<6) + data[3], data[4:]
    return ((data[2]<<30) + (data[3]<<24) + (data[4]<<18) +
            (data[5]<<12) + (data[6]<<6) + data[7], data[8:])

def n_to_data(n):
    """Convert an integer to one-, four- or eight-unit graph6 sequence."""
    if n < 0:
        raise NetworkXError("Numbers in graph6 format must be non-negative.")
    if n <= 62:
        return [n]
    if n <= 258047:
        return [63, (n>>12) & 0x3f, (n>>6) & 0x3f, n & 0x3f]
    if n <= 68719476735:
        return [63, 63,
            (n>>30) & 0x3f, (n>>24) & 0x3f, (n>>18) & 0x3f,
            (n>>12) & 0x3f, (n>>6) & 0x3f, n & 0x3f]
    raise NetworkXError("Numbers above 68719476735 are not supported by graph6")


text:
package application.controller;

import java.util.List;

import javafx.beans.binding.Bindings;
import javafx.beans.property.ObjectProperty;
import javafx.beans.property.SimpleObjectProperty;
import javafx.collections.FXCollections;
import javafx.collections.ListChangeListener.Change;
import javafx.fxml.FXML;
import javafx.scene.control.Label;
import javafx.scene.control.TableColumn;
import javafx.scene.control.TableView;
import application.Main;
import application.model.daten.Begegnung;
import application.model.daten.Ergebnis;
import application.model.daten.Turnier;
import application.model.daten.TurnierVeranstaltung;
import application.model.daten.Wertung;
import application.model.daten.Turnier.Status;

/**
 * Kontrolliert die Funktionalität eines Turnier-Tabs auf der AnzeigeTafel
 * @author Dennis Heller, Marvin Wohlfarth, Burak Ünal
 *
 */
public class AnzeigeTafelTabController {

	@FXML private Label stoppuhrLabel;
	@FXML private Label gewinnerLabel;
	@FXML private Label gewinnerLabelContent;
	@FXML private TableView<Integer> teilnehmerTabelle;
	@FXML private TableColumn<Integer, String> teilnehmerTabelleColumnNummer;
	@FXML private TableColumn<Integer, String> teilnehmerTabelleColumnVorname;
	@FXML private TableColumn<Integer, String> teilnehmerTabelleColumnNachname;
	@FXML private TableColumn<Integer, String> teilnehmerTabelleColumnNickname;
	@FXML private TableColumn<Integer, Number> teilnehmerTabelleColumnSiege;
	@FXML private TableColumn<Integer, Number> teilnehmerTabelleColumnModSiege;
	@FXML private TableColumn<Integer, Number> teilnehmerTabelleColumnUnentschieden;
	@FXML private TableColumn<Integer, Number> teilnehmerTabelleColumnNiederlagen;
	@FXML private TableColumn<Integer, Number> teilnehmerTabelleColumnPunkte;
	@FXML private TableColumn<Integer, Number> teilnehmerTabelleColumnSpielpunkte;
	@FXML private TableColumn<Integer, Number> teilnehmerTabelleColumnTabellenstaerke;
	@FXML private TableView<Begegnung> naechsteBegegnungenTabelle;
	@FXML private TableColumn<Begegnung, String> naechsteBegegnungenTabelleColumnSpieler1;
	@FXML private TableColumn<Begegnung, String> naechsteBegegnungenTabelleColumnSpieler2;
	@FXML private TableView<Begegnung> letzteBegegnungenTabelle;
	@FXML private TableColumn<Begegnung, String> letzteBegegnungenTabelleColumnSpieler1;
	@FXML private TableColumn<Begegnung, String> letzteBegegnungenTabelleColumnSpieler2;
	@FXML private TableColumn<Begegnung, String> letzteBegegnungenTabelleColumnErgebnis;

	private ObjectProperty<Turnier> turnier			= new SimpleObjectProperty<>();

	@FXML
	private void initialize() {
		turnier.addListener((observable, oldValue, turnier)->{
			ObjectProperty<TurnierVeranstaltung> tv = Main.turnierVeranstaltungProperty();

			stoppuhrLabel.visibleProperty().bind(turnier.getAnzeigeTafelKonfiguration().stoppuhrProperty());
			stoppuhrLabel.managedProperty().bind(turnier.getAnzeigeTafelKonfiguration().stoppuhrProperty());
			stoppuhrLabel.textProperty().bind(turnier.getStoppuhr().displayTextProperty());

			gewinnerLabel.visibleProperty().bind(turnier.statusProperty().isEqualTo(Status.BEENDET));
			gewinnerLabelContent.textProperty().bind(turnier.gewinnerTextProperty());

			teilnehmerTabelle.visibleProperty().bind(turnier.getAnzeigeTafelKonfiguration().tabelleProperty());
			teilnehmerTabelle.managedProperty().bind(turnier.getAnzeigeTafelKonfiguration().tabelleProperty());
			teilnehmerTabelleColumnNummer.setCellValueFactory(cellData->tv.get().getTeilnehmer(cellData.getValue()).displayNummerProperty());
			teilnehmerTabelleColumnVorname.setCellValueFactory(cellData->tv.get().getTeilnehmer(cellData.getValue()).vornameProperty());
			teilnehmerTabelleColumnNachname.setCellValueFactory(cellData->tv.get().getTeilnehmer(cellData.getValue()).nachnameProperty());
			teilnehmerTabelleColumnNickname.setCellValueFactory(cellData->tv.get().getTeilnehmer(cellData.getValue()).nicknameProperty());
			teilnehmerTabelleColumnSiege.setCellValueFactory(cellData->turnier.getTabelleE().get(cellData.getValue()).get(Ergebnis.SIEG));
			teilnehmerTabelleColumnModSiege.setCellValueFactory(cellData->turnier.getTabelleE().get(cellData.getValue()).get(Ergebnis.MOD_SIEG));
			teilnehmerTabelleColumnUnentschieden.setCellValueFactory(cellData->turnier.getTabelleE().get(cellData.getValue()).get(Ergebnis.UNENTSCHIEDEN));
			teilnehmerTabelleColumnNiederlagen.setCellValueFactory(cellData->turnier.getTabelleE().get(cellData.getValue()).get(Ergebnis.NIEDERLAGE));
			teilnehmerTabelleColumnPunkte.setCellValueFactory(cellData->turnier.getTabelleW().get(cellData.getValue()).get(Wertung.SIEGPUNKTE));
			teilnehmerTabelleColumnSpielpunkte.setCellValueFactory(cellData->turnier.getTabelleW().get(cellData.getValue()).get(Wertung.SPIELPUNKTE));
			teilnehmerTabelleColumnTabellenstaerke.setCellValueFactory(cellData->turnier.getTabelleW().get(cellData.getValue()).get(Wertung.TABELLENSTAERKE));
			teilnehmerTabelle.setItems(turnier.getTeilnehmerListe());

			naechsteBegegnungenTabelle.visibleProperty().bind(turnier.getAnzeigeTafelKonfiguration().naechstePaarungenProperty());
			naechsteBegegnungenTabelle.managedProperty().bind(turnier.getAnzeigeTafelKonfiguration().naechstePaarungenProperty());
			naechsteBegegnungenTabelleColumnSpieler1.setCellValueFactory(cellData->Bindings.concat(" (", tv.get().getTeilnehmer(cellData.getValue().getDaten1().getSpieler()).displayNummerProperty(),")  ", tv.get().getTeilnehmer(cellData.getValue().getDaten1().getSpieler()).displayNameProperty()));
			naechsteBegegnungenTabelleColumnSpieler2.setCellValueFactory(cellData->Bindings.concat(" (", tv.get().getTeilnehmer(cellData.getValue().getDaten2().getSpieler()).displayNummerProperty(),")  ", tv.get().getTeilnehmer(cellData.getValue().getDaten2().getSpieler()).displayNameProperty()));
			naechsteBegegnungenTabelle.setItems(turnier.getAktuelleBegegnungen().filtered(begegnung->!begegnung.getGespielt()));

			letzteBegegnungenTabelle.visibleProperty().bind(turnier.getAnzeigeTafelKonfiguration().letzteErgebnisseProperty().greaterThan(0));
			letzteBegegnungenTabelle.managedProperty().bind(turnier.getAnzeigeTafelKonfiguration().letzteErgebnisseProperty().greaterThan(0));
			letzteBegegnungenTabelleColumnSpieler1.setCellValueFactory(cellData->Bindings.concat(" (", tv.get().getTeilnehmer(cellData.getValue().getDaten1().getSpieler()).displayNummerProperty(),")  ", tv.get().getTeilnehmer(cellData.getValue().getDaten1().getSpieler()).displayNameProperty()));
			letzteBegegnungenTabelleColumnSpieler2.setCellValueFactory(cellData->Bindings.concat(" (", tv.get().getTeilnehmer(cellData.getValue().getDaten2().getSpieler()).displayNummerProperty(),")  ", tv.get().getTeilnehmer(cellData.getValue().getDaten2().getSpieler()).displayNameProperty()));
			letzteBegegnungenTabelleColumnErgebnis.setCellValueFactory(cellData->Bindings.when(cellData.getValue().gespieltProperty()).then(Bindings.concat(cellData.getValue().getDaten1().punkteProperty(),":",cellData.getValue().getDaten2().punkteProperty())).otherwise(""));
			letzteBegegnungenTabelle.setItems(turnier.getAktuelleBegegnungen().filtered(begegnung->begegnung.getGespielt()));

			turnier.getAktuelleBegegnungen().addListener((Change<? extends Begegnung> c)->{
				updateLetzteBegegnungen();
			});
			turnier.getAnzeigeTafelKonfiguration().letzteErgebnisseProperty().addListener((observable2, oldValue2, newValue2)->{
				updateLetzteBegegnungen();
			});
		});
	}

	private void updateLetzteBegegnungen() {
		List<Begegnung> items = getTurnier().getAktuelleBegegnungen().filtered(begegnung->begegnung.getGespielt());
		items = items.subList(Math.max(0, items.size()-getTurnier().getAnzeigeTafelKonfiguration().getLetzteErgebnisse()), items.size());
		letzteBegegnungenTabelle.setItems(FXCollections.observableList(items));
	}

	public Turnier getTurnier() {
		return turnier.get();
	}

	public void setTurnier(Turnier turnier) {
		this.turnier.set(turnier);
	}

}

redpajama_set_name: RedPajamaGithub


text:
/**
 * @class Ext.lib.Container
 * @extends Ext.Component
 * Shared Container class
 */
Ext.lib.Container = Ext.extend(Ext.Component, {
    /**
     * @cfg {String/Object} layout
     *
*Important: In order for child items to be correctly sized and
     * positioned, typically a layout manager must be specified through
     * the layout configuration option.

     *

The sizing and positioning of child {@link items} is the responsibility of
     * the Container's layout manager which creates and manages the type of layout
     * you have in mind.  For example:

     *
If the {@link #layout} configuration is not explicitly specified for
     * a general purpose container (e.g. Container or Panel) the
     * {@link Ext.layout.AutoContainerLayout default layout manager} will be used
     * which does nothing but render child components sequentially into the
     * Container (no sizing or positioning will be performed in this situation).

     *

layout may be specified as either as an Object or
     * as a String:

     *
     *
Specify as an Object

     *

     *
Example usage:

     *

layout: {
    type: 'vbox',
    align: 'left'
}

     *
     *
type

     *

The layout type to be used for this container.  If not specified,
     * a default {@link Ext.layout.ContainerLayout} will be created and used.

     *

Valid layout type values are:

     *

     *
{@link Ext.layout.ContainerLayout auto}     Default

     *
{@link Ext.layout.CardLayout card}

     *
{@link Ext.layout.FitLayout fit}

     *
{@link Ext.layout.HBoxLayout hbox}

     *
{@link Ext.layout.VBoxLayout vbox}

     *

     *
     *
Layout specific configuration properties

     *

Additional layout specific configuration properties may also be
     * specified. For complete details regarding the valid config options for
     * each layout type, see the layout class corresponding to the type
     * specified.

     *
     *

     *
     *
Specify as a String

     *

     *
Example usage:

     *

layout: {
    type: 'vbox',
    padding: '5',
    align: 'left'
}

     *
layout

     *

The layout type to be used for this container (see list
     * of valid layout type values above).

     *

Additional layout specific configuration properties. For complete
     * details regarding the valid config options for each layout type, see the
     * layout class corresponding to the layout specified.

     *

     */

    /**
     * @cfg {String/Number} activeItem
     * A string component id or the numeric index of the component that should be initially activated within the
     * container's layout on render.  For example, activeItem: 'item-1' or activeItem: 0 (index 0 = the first
     * item in the container's collection).  activeItem only applies to layout styles that can display
     * items one at a time (like {@link Ext.layout.CardLayout} and
     * {@link Ext.layout.FitLayout}).  Related to {@link Ext.layout.ContainerLayout#activeItem}.
     */
    /**
     * @cfg {Object/Array} items
     *
** IMPORTANT: be sure to {@link #layout specify a layout} if needed ! **

     *
A single item, or an array of child Components to be added to this container,
     * for example:

     *

// specifying a single item
items: {...},
layout: 'fit',    // specify a layout!

// specifying multiple items
items: [{...}, {...}],
layout: 'hbox', // specify a layout!

     *
Each item may be:

     *

     *
any type of object based on {@link Ext.Component}

     *
a fully instanciated object or

     *
an object literal that:

     *

     *
has a specified {@link Ext.Component#xtype xtype}

     *
the {@link Ext.Component#xtype} specified is associated with the Component
     * desired and should be chosen from one of the available xtypes as listed
     * in {@link Ext.Component}.

     *
If an {@link Ext.Component#xtype xtype} is not explicitly
     * specified, the {@link #defaultType} for that Container is used.

     *
will be "lazily instanciated", avoiding the overhead of constructing a fully
     * instanciated Component object

     *

     *
Notes:

     *

     *
Ext uses lazy rendering. Child Components will only be rendered
     * should it become necessary. Items are automatically laid out when they are first
     * shown (no sizing is done while hidden), or in response to a {@link #doLayout} call.

     *
Do not specify {@link Ext.Panel#contentEl contentEl}/
     * {@link Ext.Panel#html html} with items.

     *

     */
    /**
     * @cfg {Object|Function} defaults
     *
This option is a means of applying default settings to all added items whether added through the {@link #items}
     * config or via the {@link #add} or {@link #insert} methods.

     *
If an added item is a config object, and not an instantiated Component, then the default properties are
     * unconditionally applied. If the added item is an instantiated Component, then the default properties are
     * applied conditionally so as not to override existing properties in the item.

     *
If the defaults option is specified as a function, then the function will be called using this Container as the
     * scope (this reference) and passing the added item as the first parameter. Any resulting object
     * from that call is then applied to the item as default properties.

     *
For example, to automatically apply padding to the body of each of a set of
     * contained {@link Ext.Panel} items, you could pass: defaults: {bodyStyle:'padding:15px'}.

     *
Usage:

defaults: {               // defaults are applied to items, not the container
    autoScroll:true
},
items: [
    {
        xtype: 'panel',   // defaults do not have precedence over
        id: 'panel1',     // options in config objects, so the defaults
        autoScroll: false // will not be applied here, panel1 will be autoScroll:false
    },
    new Ext.Panel({       // defaults do have precedence over options
        id: 'panel2',     // options in components, so the defaults
        autoScroll: false // will be applied here, panel2 will be autoScroll:true.
    })
]

     */

    /** @cfg {Boolean} autoDestroy
     * If true the container will automatically destroy any contained component that is removed from it, else
     * destruction must be handled manually (defaults to true).
     */
    autoDestroy : true,

     /** @cfg {String} defaultType
      *
The default {@link Ext.Component xtype} of child Components to create in this Container when
      * a child item is specified as a raw configuration object, rather than as an instantiated Component.

      *
Defaults to 'panel'.

      */
    defaultType: 'panel',

    isContainer : true,

    baseCls: 'x-container',

    /**
     * @cfg {Array} bubbleEvents
     *
An array of events that, when fired, should be bubbled to any parent container.
     * See {@link Ext.util.Observable#enableBubble}.
     * Defaults to ['add', 'remove'].
     */
    bubbleEvents: ['add', 'remove'],

    // @private
    initComponent : function(){
        this.addEvents(
            /**
             * @event afterlayout
             * Fires when the components in this container are arranged by the associated layout manager.
             * @param {Ext.Container} this
             * @param {ContainerLayout} layout The ContainerLayout implementation for this container
             */
            'afterlayout',
            /**
             * @event beforeadd
             * Fires before any {@link Ext.Component} is added or inserted into the container.
             * A handler can return false to cancel the add.
             * @param {Ext.Container} this
             * @param {Ext.Component} component The component being added
             * @param {Number} index The index at which the component will be added to the container's items collection
             */
            'beforeadd',
            /**
             * @event beforeremove
             * Fires before any {@link Ext.Component} is removed from the container.  A handler can return
             * false to cancel the remove.
             * @param {Ext.Container} this
             * @param {Ext.Component} component The component being removed
             */
            'beforeremove',
            /**
             * @event add
             * @bubbles
             * Fires after any {@link Ext.Component} is added or inserted into the container.
             * @param {Ext.Container} this
             * @param {Ext.Component} component The component that was added
             * @param {Number} index The index at which the component was added to the container's items collection
             */
            'add',
            /**
             * @event remove
             * @bubbles
             * Fires after any {@link Ext.Component} is removed from the container.
             * @param {Ext.Container} this
             * @param {Ext.Component} component The component that was removed
             */
            'remove',
            /**
             * @event beforecardswitch
             * Fires before this container switches the active card. This event
             * is only available if this container uses a CardLayout. Note that
             * TabPanel and Carousel both get a CardLayout by default, so both
             * will have this event.
             * A handler can return false to cancel the card switch.
             * @param {Ext.Container} this
             * @param {Ext.Component} newCard The card that will be switched to
             * @param {Ext.Component} oldCard The card that will be switched from
             * @param {Number} index The index of the card that will be switched to
             * @param {Boolean} animated True if this cardswitch will be animated
             */
            'beforecardswitch',
            /**
             * @event cardswitch
             * Fires after this container switches the active card. If the card
             * is switched using an animation, this event will fire after the
             * animation has finished. This event is only available if this container
             * uses a CardLayout. Note that TabPanel and Carousel both get a CardLayout
             * by default, so both will have this event.
             * @param {Ext.Container} this
             * @param {Ext.Component} newCard The card that has been switched to
             * @param {Ext.Component} oldCard The card that has been switched from
             * @param {Number} index The index of the card that has been switched to
             * @param {Boolean} animated True if this cardswitch was animated
             */
            'cardswitch'
        );

        // layoutOnShow stack
        this.layoutOnShow = new Ext.util.MixedCollection();
        Ext.lib.Container.superclass.initComponent.call(this);
        this.initItems();
    },

    // @private
    initItems : function() {
        var items = this.items;

        /**
         * The MixedCollection containing all the child items of this container.
         * @property items
         * @type Ext.util.MixedCollection
         */
        this.items = new Ext.util.MixedCollection(false, this.getComponentId);

        if (items) {
            if (!Ext.isArray(items)) {
                items = [items];
            }

            this.add(items);
        }
    },

    // @private
    afterRender : function() {
        this.getLayout();
        Ext.lib.Container.superclass.afterRender.apply(this, arguments);
    },

    // @private
    setLayout : function(layout) {
        var currentLayout = this.layout;

        if (currentLayout && currentLayout.isLayout && currentLayout != layout) {
            currentLayout.setOwner(null);
        }

        this.layout = layout;
        layout.setOwner(this);
    },

    /**
     * Returns the {@link Ext.layout.ContainerLayout layout} instance currently associated with this Container.
     * If a layout has not been instantiated yet, that is done first
     * @return {Ext.layout.ContainerLayout} The layout
     */
    getLayout : function() {
        if (!this.layout || !this.layout.isLayout) {
            this.setLayout(Ext.layout.LayoutManager.create(this.layout, 'autocontainer'));
        }

        return this.layout;
    },

    /**
     * Force this container's layout to be recalculated. A call to this function is required after adding a new component
     * to an already rendered container, or possibly after changing sizing/position properties of child components.
     * @return {Ext.Container} this
     */
    doLayout : function() {
        var layout = this.getLayout();

        if (this.rendered && layout) {
            layout.layout();
        }

        return this;
    },

    // @private
    afterLayout : function(layout) {
        this.fireEvent('afterlayout', this, layout);
    },

    // @private
    prepareItems : function(items, applyDefaults) {
        if (!Ext.isArray(items)) {
            items = [items];
        }

        // Make sure defaults are applied and item is initialized
        var item, i, ln;

        for (i = 0, ln = items.length; i < ln; i++) {
            item = items[i];

            if (applyDefaults) {
                item = this.applyDefaults(item);
            }

            items[i] = this.lookupComponent(item);
        }

        return items;
    },

    // @private
    applyDefaults : function(config) {
        var defaults = this.defaults;

        if (defaults) {
            if (Ext.isFunction(defaults)) {
                defaults = defaults.call(this, config);
            }

            if (Ext.isString(config)) {
                config = Ext.ComponentMgr.get(config);
                Ext.apply(config, defaults);
            } else if (!config.isComponent) {
                Ext.applyIf(config, defaults);
            } else {
                Ext.apply(config, defaults);
            }
        }

        return config;
    },

    // @private
    lookupComponent : function(comp) {
        if (Ext.isString(comp)) {
            return Ext.ComponentMgr.get(comp);
        } else {
            return this.createComponent(comp);
        }
        return comp;
    },

    // @private
    createComponent : function(config, defaultType) {
        if (config.isComponent) {
            return config;
        }

        // // add in ownerCt at creation time but then immediately
        // // remove so that onBeforeAdd can handle it
        // var component = Ext.create(Ext.apply({ownerCt: this}, config), defaultType || this.defaultType);
        //
        // delete component.initialConfig.ownerCt;
        // delete component.ownerCt;

        return Ext.create(config, defaultType || this.defaultType);
    },

    // @private - used as the key lookup function for the items collection
    getComponentId : function(comp) {
        return comp.getItemId();
    },

    /**
     *
Adds {@link Ext.Component Component}(s) to this Container.

     *

Description :
     *

     *
Fires the {@link #beforeadd} event before adding

     *
The Container's {@link #defaults default config values} will be applied
     * accordingly (see {@link #defaults} for details).

     *
Fires the {@link #add} event after the component has been added.

     *

     *

Notes :
     *

     *
If the Container is already rendered when add
     * is called, you may need to call {@link #doLayout} to refresh the view which causes
     * any unrendered child Components to be rendered. This is required so that you can
     * add multiple child components if needed while only refreshing the layout
     * once. For example:

var tb = new {@link Ext.Toolbar}();
tb.render(document.body);  // toolbar is rendered
tb.add({text:'Button 1'}); // add multiple items ({@link #defaultType} for {@link Ext.Toolbar Toolbar} is 'button')
tb.add({text:'Button 2'});
tb.{@link #doLayout}();             // refresh the layout
     *

     *
Warning: Containers directly managed by the BorderLayout layout manager
     * may not be removed or added.  See the Notes for {@link Ext.layout.BorderLayout BorderLayout}
     * for more details.

     *

     * @param {...Object/Array} component
     *
Either one or more Components to add or an Array of Components to add.  See
     * {@link #items} for additional information.

     * @return {Ext.Component/Array} The Components that were added.
     */
    add : function() {
        var args = Array.prototype.slice.call(arguments),
            index = -1;

        if (typeof args[0] == 'number') {
            index = args.shift();
        }

        var hasMultipleArgs = args.length > 1;

        if (hasMultipleArgs || Ext.isArray(args[0])) {
            var items = hasMultipleArgs ? args : args[0],
                results = [],
                i, ln, item;

            for (i = 0, ln = items.length; i < ln; i++) {
                item = items[i];
                if (!item) {
                    throw "Trying to add a null item as a child of Container with itemId/id: " + this.getItemId();
                }

                if (index != -1) {
                    item = this.add(index + i, item);
                } else {
                    item = this.add(item);
                }
                results.push(item);
            }

            return results;
        }

        var cmp = this.prepareItems(args[0], true)[0];
        index = (index !== -1) ? index : this.items.length;

        if (this.fireEvent('beforeadd', this, cmp, index) !== false && this.onBeforeAdd(cmp) !== false) {
            this.items.insert(index, cmp);
            cmp.onAdded(this, index);
            this.onAdd(cmp, index);
            this.fireEvent('add', this, cmp, index);
        }

        return cmp;
    },

    onAdd : Ext.emptyFn,
    onRemove : Ext.emptyFn,

    /**
     * Inserts a Component into this Container at a specified index. Fires the
     * {@link #beforeadd} event before inserting, then fires the {@link #add} event after the
     * Component has been inserted.
     * @param {Number} index The index at which the Component will be inserted
     * into the Container's items collection
     * @param {Ext.Component} component The child Component to insert.

     * Ext uses lazy rendering, and will only render the inserted Component should
     * it become necessary.

     * A Component config object may be passed in order to avoid the overhead of
     * constructing a real Component object if lazy rendering might mean that the
     * inserted Component will not be rendered immediately. To take advantage of
     * this 'lazy instantiation', set the {@link Ext.Component#xtype} config
     * property to the registered type of the Component wanted.

     * For a list of all available xtypes, see {@link Ext.Component}.
     * @return {Ext.Component} component The Component (or config object) that was
     * inserted with the Container's default config values applied.
     */
    insert : function(index, comp){
        return this.add(index, comp);
    },

    // @private
    onBeforeAdd : function(item) {
        if (item.ownerCt) {
            item.ownerCt.remove(item, false);
        }

        if (this.hideBorders === true){
            item.border = (item.border === true);
        }
    },

    /**
     * Removes a component from this container.  Fires the {@link #beforeremove} event before removing, then fires
     * the {@link #remove} event after the component has been removed.
     * @param {Component/String} component The component reference or id to remove.
     * @param {Boolean} autoDestroy (optional) True to automatically invoke the removed Component's {@link Ext.Component#destroy} function.
     * Defaults to the value of this Container's {@link #autoDestroy} config.
     * @return {Ext.Component} component The Component that was removed.
     */
    remove : function(comp, autoDestroy) {
        var c = this.getComponent(comp);
        //<debug>
			if (!c) {
            	console.warn("Attempted to remove a component that does not exist. Ext.Container: remove takes an argument of the component to remove. cmp.remove() is incorrect usage.");
			}
        //</debug>

        if (c && this.fireEvent('beforeremove', this, c) !== false) {
            this.doRemove(c, autoDestroy);
            this.fireEvent('remove', this, c);
        }

        return c;
    },

    // @private
    doRemove : function(component, autoDestroy) {
        var layout = this.layout,
            hasLayout = layout && this.rendered;

        this.items.remove(component);
        component.onRemoved();

        if (hasLayout) {
            layout.onRemove(component);
        }

        this.onRemove(component, autoDestroy);

        if (autoDestroy === true || (autoDestroy !== false && this.autoDestroy)) {
            component.destroy();
        }

        if (hasLayout && !autoDestroy) {
            layout.afterRemove(component);
        }
    },

    /**
     * Removes all components from this container.
     * @param {Boolean} autoDestroy (optional) True to automatically invoke the removed Component's {@link Ext.Component#destroy} function.
     * Defaults to the value of this Container's {@link #autoDestroy} config.
     * @return {Array} Array of the destroyed components
     */
    removeAll : function(autoDestroy) {
        var item,
            removeItems = this.items.items.slice(),
            items = [],
            ln = removeItems.length,
            i;

        for (i = 0; i < ln; i++) {
            item = removeItems[i];
            this.remove(item, autoDestroy);

            if (item.ownerCt !== this) {
                items.push(item);
            }
        }

        return items;
    },

    // Used by ComponentQuery to retrieve all of the items
    // which can potentially be considered a child of this Container.
    // This should be overriden by components which have child items
    // that are not contained in items. For example dockedItems, menu, etc
    getRefItems : function(deep) {
        var items = this.items.items.slice(),
            ln = items.length,
            i, item;

        if (deep) {
            for (i = 0; i < ln; i++) {
                item = items[i];

                if (item.getRefItems) {
                    items = items.concat(item.getRefItems(true));
                }
            }
        }

        return items;
    },

    /**
     * Examines this container's {@link #items} property
     * and gets a direct child component of this container.
     * @param {String/Number} comp This parameter may be any of the following:
     *

     *
a String : representing the {@link Ext.Component#itemId itemId}
     * or {@link Ext.Component#id id} of the child component

     *
a Number : representing the position of the child component
     * within the {@link #items} property

     *

     *
For additional information see {@link Ext.util.MixedCollection#get}.
     * @return Ext.Component The component (if found).
     */
    getComponent : function(comp) {
        if (Ext.isObject(comp)) {
            comp = comp.getItemId();
        }

        return this.items.get(comp);
    },

    /**
     * Retrieves all descendant components which match the passed selector.
     * Executes an Ext.ComponentQuery.query using this container as its root.
     * @param {String} selector Selector complying to an Ext.ComponentQuery selector
     * @return {Array} Ext.Component's which matched the selector
     */
    query : function(selector) {
        return Ext.ComponentQuery.query(selector, this);
    },

    /**
     * Retrieves the first direct child of this container which matches the passed selector.
     * The passed in selector must comply with an Ext.ComponentQuery selector.
     * @param {String} selector An Ext.ComponentQuery selector
     * @return Ext.Component
     */
    child : function(selector) {
        return this.query('> ' + selector)[0] || null;
    },

    /**
     * Retrieves the first descendant of this container which matches the passed selector.
     * The passed in selector must comply with an Ext.ComponentQuery selector.
     * @param {String} selector An Ext.ComponentQuery selector
     * @return Ext.Component
     */
    down : function(selector) {
        return this.query(selector)[0] || null;
    },

    // inherit docs
    show : function() {
        Ext.lib.Container.superclass.show.apply(this, arguments);

        var layoutCollection = this.layoutOnShow,
            ln = layoutCollection.getCount(),
            i = 0,
            needsLayout,
            item;

        for (; i < ln; i++) {
            item = layoutCollection.get(i);
            needsLayout = item.needsLayout;

            if (Ext.isObject(needsLayout)) {
                item.doComponentLayout(needsLayout.width, needsLayout.height, needsLayout.isSetSize);
            }
        }

        layoutCollection.clear();
    },

    // @private
    beforeDestroy : function() {
        var items = this.items,
            c;

        if (items) {
            while ((c = items.first())) {
                this.doRemove(c, true);
            }
        }

        Ext.destroy(this.layout);
        Ext.lib.Container.superclass.beforeDestroy.call(this);
    }
});

// Declare here so we can test
Ext.Container = Ext.extend(Ext.lib.Container, {});
Ext.reg('container', Ext.Container);


text:
package delta_test

import (
	"testing"

	"github.com/GeoNet/delta/meta"
)

var testInstalledAntennas = map[string]func([]meta.InstalledAntenna) func(t *testing.T){

	// check for session overlaps, there can't be two sessions running at the same mark for the same sampling interval.
	"check antenna installation overlap": func(installedAntennas []meta.InstalledAntenna) func(t *testing.T) {
		return func(t *testing.T) {

			installs := make(map[string]meta.InstalledAntennaList)
			for _, s := range installedAntennas {
				if _, ok := installs[s.Model]; !ok {
					installs[s.Model] = meta.InstalledAntennaList{}
				}
				installs[s.Model] = append(installs[s.Model], s)
			}

			for _, v := range installs {
				for i := 0; i < len(v); i++ {
					for j := i + 1; j < len(v); j++ {
						if v[i].Serial != v[j].Serial {
							continue
						}
						if v[i].End.Before(v[j].Start) {
							continue
						}
						if v[i].Start.After(v[j].End) {
							continue
						}
						if v[i].End.Equal(v[j].Start) {
							continue
						}
						if v[i].Start.Equal(v[j].End) {
							continue
						}
						t.Errorf("installed antennas %s [%s] at %s has overlap at %s between %s and %s",
							v[i].Model, v[i].Serial, v[i].Mark, v[j].Mark,
							v[i].Start.Format(meta.DateTimeFormat),
							v[i].End.Format(meta.DateTimeFormat))
					}
				}
			}
		}
	},

	"check for antenna installation mark overlaps": func(installedAntennas []meta.InstalledAntenna) func(t *testing.T) {
		return func(t *testing.T) {
			installs := make(map[string]meta.InstalledAntennaList)
			for _, s := range installedAntennas {
				if _, ok := installs[s.Mark]; !ok {
					installs[s.Mark] = meta.InstalledAntennaList{}
				}
				installs[s.Mark] = append(installs[s.Mark], s)
			}

			for _, v := range installs {
				for i := 0; i < len(v); i++ {
					for j := i + 1; j < len(v); j++ {
						if v[i].End.Before(v[j].Start) {
							continue
						}
						if v[i].Start.After(v[j].End) {
							continue
						}
						if v[i].End.Equal(v[j].Start) {
							continue
						}
						if v[i].Start.Equal(v[j].End) {
							continue
						}
						t.Errorf("installed antennas %s [%s] and %s [%s] at %s has an overlap between %s and %s",
							v[i].Model, v[i].Serial, v[j].Model, v[j].Serial, v[i].Mark,
							v[i].Start.Format(meta.DateTimeFormat), v[i].End.Format(meta.DateTimeFormat))
					}
				}
			}
		}
	},
}

var testInstalledAntennasMarks = map[string]func([]meta.InstalledAntenna, []meta.Mark) func(t *testing.T){
	"check for missing antenna marks": func(installedAntennas []meta.InstalledAntenna, marks []meta.Mark) func(t *testing.T) {
		return func(t *testing.T) {

			keys := make(map[string]interface{})
			for _, m := range marks {
				keys[m.Code] = true
			}

			for _, c := range installedAntennas {
				if _, ok := keys[c.Mark]; !ok {
					t.Errorf("unable to find antenna mark %-5s", c.Mark)
				}
			}
		}
	},
}

var testInstalledAntennasAssets = map[string]func([]meta.InstalledAntenna, []meta.Asset) func(t *testing.T){
	"check for missing antenna assets": func(installedAntennas []meta.InstalledAntenna, assets []meta.Asset) func(t *testing.T) {
		return func(t *testing.T) {
			for _, r := range installedAntennas {
				var found bool
				for _, a := range assets {
					if a.Model != r.Model {
						continue
					}
					if a.Serial != r.Serial {
						continue
					}
					found = true
				}
				if found {
					continue
				}
				t.Errorf("unable to find antenna asset: %s [%s]", r.Model, r.Serial)
			}
		}
	},
}

var testInstalledAntennasSessions = map[string]func([]meta.InstalledAntenna, []meta.Session) func(t *testing.T){
	"check for missing antenna sessions": func(installedAntennas []meta.InstalledAntenna, sessions []meta.Session) func(t *testing.T) {
		return func(t *testing.T) {

			for _, r := range installedAntennas {
				var found bool
				for _, s := range sessions {
					if s.End.Before(r.Start) {
						continue
					}
					if s.Start.After(r.End) {
						continue
					}
					found = true
				}
				if found {
					continue
				}
				t.Errorf("unable to find antenna session: %s [%s]", r.Model, r.Serial)
			}
		}
	},
}

func TestInstalledAntennas(t *testing.T) {

	var installedAntennas meta.InstalledAntennaList
	loadListFile(t, "../install/antennas.csv", &installedAntennas)

	for k, fn := range testInstalledAntennas {
		t.Run(k, fn(installedAntennas))
	}
}

func TestInstalledAntennas_Marks(t *testing.T) {

	var installedAntennas meta.InstalledAntennaList
	loadListFile(t, "../install/antennas.csv", &installedAntennas)

	var marks meta.MarkList
	loadListFile(t, "../network/marks.csv", &marks)

	for k, fn := range testInstalledAntennasMarks {
		t.Run(k, fn(installedAntennas, marks))
	}

}

func TestInstalledAntennas_Assets(t *testing.T) {

	var installedAntennas meta.InstalledAntennaList
	loadListFile(t, "../install/antennas.csv", &installedAntennas)

	var assets meta.AssetList
	loadListFile(t, "../assets/antennas.csv", &assets)

	for k, fn := range testInstalledAntennasAssets {
		t.Run(k, fn(installedAntennas, assets))
	}
}

func TestInstalledAntennas_Sessions(t *testing.T) {

	var installedAntennas meta.InstalledAntennaList
	loadListFile(t, "../install/antennas.csv", &installedAntennas)

	var sessions meta.SessionList
	loadListFile(t, "../install/sessions.csv", &sessions)

	for k, fn := range testInstalledAntennasSessions {
		t.Run(k, fn(installedAntennas, sessions))
	}
}


text:
SYNONYM

#### According to
The Catalogue of Life, 3rd January 2011

#### Published in
Mycologia 47: 205 (1955)

#### Original name
Circinella linderi Hesselt. & Fennell, 1955

### Remarks
null


text:
package com.shortsands.aws;

import android.util.Log;
import com.shortsands.io.FileManager;
/**
 * Created by garygriswold on 5/22/17.
 */

public class DownloadDataListener extends AwsS3AbstractListener {

    private static String TAG = "DownloadDataListener";

    public byte[] results = null;

    public DownloadDataListener() {
        super();
    }

    @Override
    protected void onComplete(int id) {
        super.onComplete(id);
        this.results = FileManager.readBinaryFully(this.file);
        try { this.file.delete(); } catch(Exception e) {}
        Log.d(TAG, "Received: " + this.results);
    }
}


text:
docker_lbspec_test
==================

Doeckerfile and related files to test lbspec


text:
package org.robolectric.android.internal;

public class ClassNameResolver<T> {
  private String packageName;
  private String className;

  public ClassNameResolver(String packageName, String className) {
    this.packageName = packageName;
    this.className = className;
  }

  public Class<? extends T> resolve() throws ClassNotFoundException {
    Class<? extends T> aClass;
    if (looksFullyQualified(className)) {
      aClass = safeClassForName(className);
    } else {
      if (className.startsWith(".")) {
        aClass = safeClassForName(packageName + className);
      } else {
        aClass = safeClassForName(packageName + "." + className);
      }
    }

    if (aClass == null) {
      throw new ClassNotFoundException("Could not find a class for package: "
          + packageName + " and class name: " + className);
    }
    return aClass;
  }

  private boolean looksFullyQualified(String className) {
    return className.contains(".") && !className.startsWith(".");
  }

  private Class<? extends T> safeClassForName(String classNamePath) {
    try {
      return (Class<? extends T>) Class.forName(classNamePath);
    } catch (ClassNotFoundException e) {
      return null;
    }
  }
}


text:
class CRichBox : public CRichEditCtrl
{
	//DECLARE_DYNAMIC(CStatic)

public:
	virtual BOOL Create( LPCTSTR lpszText, DWORD dwStyle, const RECT& rect, CWnd* pParentWnd, UINT nID = 0xffff );

	CDC dcTarget;
	//CRichEditCtrl cEdit;
public:
	//operator CRichEditCtrl& ( ) { return cEdit; }
	DECLARE_MESSAGE_MAP( )
	afx_msg int OnCreate( LPCREATESTRUCT lpCreateStruct );
};

class CAboutDlg : public CDialogEx
{
public:
	CAboutDlg();
	CRichBox cRichAck;

// Dialog Data
	enum { IDD = IDD_ABOUTBOX };

protected:
	virtual void DoDataExchange(CDataExchange* pDX);    // DDX/DDV support

// Implementation
protected:
	DECLARE_MESSAGE_MAP()
public:
	virtual BOOL OnInitDialog();
	double valDouble;
};


text:
import os
import time
import Queue

from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler, DirModifiedEvent

class EventHandler(FileSystemEventHandler):

    def __init__(self, env, output_path=None):
        self.env = env
        if output_path is not None:
            output_path = os.path.join(env.root_path, output_path)
        self.output_path = output_path
        self.queue = Queue.Queue()

    def is_uninteresting(self, event):
        path = event.src_path
        if self.env.is_uninteresting_source_name(os.path.basename(path)):
            return True
        if self.output_path is not None and \
           os.path.abspath(path).startswith(self.output_path):
            return True
        return False

    def on_any_event(self, event):
        if self.is_uninteresting(event) or isinstance(event, DirModifiedEvent):
            return
        self.queue.put((time.time(), event.event_type, event.src_path))

class Watcher(object):

    def __init__(self, env, output_path=None):
        self.env = env
        self.event_handler = EventHandler(env, output_path)
        self.observer = Observer()
        self.observer.schedule(self.event_handler, env.root_path,
                               recursive=True)
        self.observer.setDaemon(True)

    def __iter__(self):
        while 1:
            try:
                yield self.event_handler.queue.get(timeout=1)
            except Queue.Empty:
                pass

def watch(env):
    """Returns a generator of file system events in the environment."""
    watcher = Watcher(env)
    watcher.observer.start()
    try:
        for event in watcher:
            yield event
    except KeyboardInterrupt:
        watcher.observer.stop()


text:
export default {
    name: "inventories.edit.groups.edit",
    url: "/edit/:group_id",
    ncyBreadcrumb: {
        parent: "inventories.edit.groups",
        label: "{{breadcrumb.group_name}}"
    },
    views: {
        'groupForm@inventories': {
            templateProvider: function(GenerateForm, GroupForm) {
                let form = GroupForm;
                return GenerateForm.buildHTML(form, {
                    mode: 'edit',
                    related: false
                });
            },
            controller: 'GroupEditController'
        }
    },
    resolve: {
        groupData: ['$stateParams', 'GroupsService', function($stateParams, GroupsService) {
            return GroupsService.get({ id: $stateParams.group_id }).then(res => res.data.results[0]);
        }]
    }
};


text:
/*	$NetBSD: evconfig-private.h,v 1.2.2.2 2014/12/24 00:05:25 riz Exp $	*/

/* evconfig-private.h.  Generated from evconfig-private.h.in by configure.  */
/* evconfig-private.h template - see "Configuration Header Templates" */
/* in AC manual.  Kevin Bowling <kevin.bowling@kev009.com */
#ifndef EVCONFIG_PRIVATE_H_INCLUDED_
#define EVCONFIG_PRIVATE_H_INCLUDED_

/* Enable extensions on AIX 3, Interix.  */
#ifndef _ALL_SOURCE
# define _ALL_SOURCE 1
#endif
/* Enable GNU extensions on systems that have them.  */
#ifndef _GNU_SOURCE
# define _GNU_SOURCE 1
#endif
/* Enable threading extensions on Solaris.  */
#ifndef _POSIX_PTHREAD_SEMANTICS
# define _POSIX_PTHREAD_SEMANTICS 1
#endif
/* Enable extensions on HP NonStop.  */
#ifndef _TANDEM_SOURCE
# define _TANDEM_SOURCE 1
#endif
/* Enable general extensions on Solaris.  */
#ifndef __EXTENSIONS__
# define __EXTENSIONS__ 1
#endif

/* Number of bits in a file offset, on hosts where this is settable. */
#define _FILE_OFFSET_BITS 64
/* Define for large files, on AIX-style hosts. */
/* #undef _LARGE_FILES */

/* Define to 1 if on MINIX. */
#ifndef _MINIX
/* #undef _MINIX */
#endif

/* Define to 2 if the system does not provide POSIX.1 features except with
   this defined. */
#ifndef _POSIX_1_SOURCE
/* #undef _POSIX_1_SOURCE */
#endif

/* Define to 1 if you need to in order for `stat' and other things to work. */
#ifndef _POSIX_SOURCE
/* #undef _POSIX_SOURCE */
#endif

#endif