//=============================================================================
// MuseScore
// Music Composition & Notation
//
// Copyright (C) 2009-2011 Werner Schweer
//
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License version 2
// as published by the Free Software Foundation and appearing in
// the file LICENCE.GPL
//=============================================================================
#include "repeatlist.h"
#include "score.h"
#include "measure.h"
#include "tempo.h"
#include "volta.h"
#include "segment.h"
#include "marker.h"
#include "jump.h"
namespace Ms {
//---------------------------------------------------------
// searchLabel
// @param startMeasure From this measure, if nullptr from firstMeasure
// @param endMeasure Up to and including this measure, if nullptr till end of score
//---------------------------------------------------------
Measure* Score::searchLabel(const QString& s, Measure* startMeasure, Measure* endMeasure)
{
if (nullptr == startMeasure)
startMeasure = firstMeasure();
if (nullptr == endMeasure)
endMeasure = lastMeasure();
if (s == "start")
return startMeasure;
else if (s == "end")
return endMeasure;
endMeasure = endMeasure->nextMeasure(); // stop comparison needs measure one past the last one to check
for (Measure* m = startMeasure; m && (m != endMeasure); m = m->nextMeasure()) {
for (auto e : m->el()) {
if ( (e->isMarker())
&& (toMarker(e)->label() == s)) {
return m;
}
}
}
return nullptr;
}
//---------------------------------------------------------
// searchLabelWithinSectionFirst
//---------------------------------------------------------
Measure* Score::searchLabelWithinSectionFirst(const QString& s, Measure* sectionStartMeasure, Measure* sectionEndMeasure)
{
Measure* result = searchLabel(s, sectionStartMeasure, sectionEndMeasure);
if ((nullptr == result) && (sectionStartMeasure != firstMeasure())) { // not found, expand to the front
result = searchLabel(s, nullptr, sectionStartMeasure->prevMeasure());
}
if ((nullptr == result) && (sectionEndMeasure != lastMeasure())) { // not found, expand to the end
result = searchLabel(s, sectionEndMeasure->nextMeasure(), nullptr);
}
return result;
}
//---------------------------------------------------------
// RepeatSegment
//---------------------------------------------------------
RepeatSegment::RepeatSegment()
{
tick = 0;
utick = 0;
utime = 0.0;
timeOffset = 0.0;
}
RepeatSegment::RepeatSegment(RepeatSegment * const rs, Measure * const fromMeasure, Measure * const untilMeasure)
{
tick = 0;
utick = 0;
utime = 0.0;
timeOffset = 0.0;
//copy the measure list
auto it = rs->measureList.cbegin();
if (nullptr != fromMeasure) {
//skip until fromMeasure
while ((it->first != fromMeasure) && ((++it) != rs->measureList.cend()));
}
while (it != rs->measureList.cend()) {
if ((nullptr != untilMeasure) && (it->first->no() > untilMeasure->no())) {
break;
}
measureList.push_back(std::make_pair(it->first, it->second));
++it;
}
if (!measureList.empty()) {
tick = measureList.cbegin()->first->tick().ticks();
}
}
void RepeatSegment::addMeasure(Measure * const m)
{
Q_ASSERT(measureList.empty() || measureList.back().first->nextMeasure() == m);
if (measureList.empty()) {
tick = m->tick().ticks();
}
measureList.push_back(std::make_pair(m, m->playbackCount()));
}
bool RepeatSegment::containsMeasure(Measure const * const m) const
{
for (std::pair<Measure*, int> measure : measureList)
{
if (measure.first == m)
return true;
}
return false;
}
int RepeatSegment::len() const
{
return (measureList.empty()) ? 0 : (measureList.last().first->endTick().ticks() - tick);
}
//---------------------------------------------------------
// playbackCount
// returns the playbackCount of this measure at the time it was inserted into the repeatSegment
// returns 0 if the measure is not part of this repeatSegment
//---------------------------------------------------------
int RepeatSegment::playbackCount(Measure * const m) const
{
for (std::pair<Measure*, int> measure : measureList)
{
if (measure.first == m)
return measure.second;
}
return 0;
}
//---------------------------------------------------------
// RepeatList
//---------------------------------------------------------
RepeatList::RepeatList(Score* s)
{
_score = s;
idx1 = 0;
idx2 = 0;
}
//---------------------------------------------------------
// ~RepeatList
//---------------------------------------------------------
RepeatList::~RepeatList()
{
qDeleteAll(*this);
}
//---------------------------------------------------------
// ticks
//---------------------------------------------------------
int RepeatList::ticks() const
{
if (length() > 0) {
const RepeatSegment* s = last();
return s->utick + s->len();
}
return 0;
}
//---------------------------------------------------------
// update
//---------------------------------------------------------
void RepeatList::update(bool expand)
{
if (!_scoreChanged && expand == _expanded)
return;
if (expand)
unwind();
else
flatten();
_scoreChanged = false;
}
//---------------------------------------------------------
// updateTempo
//---------------------------------------------------------
void RepeatList::updateTempo()
{
const TempoMap* tl = _score->tempomap();
int utick = 0;
qreal t = 0;
for(RepeatSegment* s : *this) {
s->utick = utick;
s->utime = t;
qreal ct = tl->tick2time(s->tick);
s->timeOffset = t - ct;
utick += s->len();
t += tl->tick2time(s->tick + s->len()) - ct;
}
}
//---------------------------------------------------------
// utick2tick
//---------------------------------------------------------
int RepeatList::utick2tick(int tick) const
{
unsigned n = size();
if (n == 0)
return tick;
if (tick < 0)
return 0;
unsigned ii = (idx1 < n) && (tick >= at(idx1)->utick) ? idx1 : 0;
for (unsigned i = ii; i < n; ++i) {
if ((tick >= at(i)->utick) && ((i + 1 == n) || (tick < at(i+1)->utick))) {
idx1 = i;
return tick - (at(i)->utick - at(i)->tick);
}
}
if (MScore::debugMode) {
qFatal("tick %d not found in RepeatList", tick);
}
return 0;
}
//---------------------------------------------------------
// tick2utick
//---------------------------------------------------------
int RepeatList::tick2utick(int tick) const
{
if (empty())
return 0;
for (const RepeatSegment* s : *this) {
if (tick >= s->tick && tick < (s->tick + s->len() ))
return s->utick + (tick - s->tick);
}
return last()->utick + (tick - last()->tick);
}
//---------------------------------------------------------
// utick2utime
//---------------------------------------------------------
qreal RepeatList::utick2utime(int tick) const
{
unsigned n = size();
unsigned ii = (idx1 < n) && (tick >= at(idx1)->utick) ? idx1 : 0;
for (unsigned i = ii; i < n; ++i) {
if ((tick >= at(i)->utick) && ((i + 1 == n) || (tick < at(i+1)->utick))) {
int t = tick - (at(i)->utick - at(i)->tick);
qreal tt = _score->tempomap()->tick2time(t) + at(i)->timeOffset;
return tt;
}
}
return 0.0;
}
//---------------------------------------------------------
// utime2utick
//---------------------------------------------------------
int RepeatList::utime2utick(qreal t) const
{
unsigned n = size();
unsigned ii = (idx2 < n) && (t >= at(idx2)->utime) ? idx2 : 0;
for (unsigned i = ii; i < n; ++i) {
if ((t >= at(i)->utime) && ((i + 1 == n) || (t < at(i+1)->utime))) {
idx2 = i;
return _score->tempomap()->time2tick(t - at(i)->timeOffset) + (at(i)->utick - at(i)->tick);
}
}
if (MScore::debugMode) {
qFatal("time %f not found in RepeatList", t);
}
return 0;
}
//---------------------------------------------------------
// dump
//---------------------------------------------------------
void RepeatList::dump() const
{
#if 0
qDebug("==Dump Repeat List:==");
for (const RepeatSegment* s : *this) {
qDebug("%p tick: %3d(%d) %3d(%d) len %d(%d) beats %f + %f", s,
s->utick / MScore::division,
s->utick / MScore::division / 4,
s->tick / MScore::division,
s->tick / MScore::division / 4,
s->len() / MScore::division,
s->len() / MScore::division / 4,
s->utime, s->timeOffset);
}
#endif
}
//---------------------------------------------------------
// flatten
/// Make this repeat list flat (don't expand repeats)
//---------------------------------------------------------
void RepeatList::flatten()
{
qDeleteAll(*this);
clear();
Measure* m = _score->firstMeasure();
if (!m)
return;
RepeatSegment* s = new RepeatSegment;
s->tick = 0;
s->utick = 0;
s->utime = 0.0;
s->timeOffset = 0.0;
do {
s->addMeasure(m);
m = m->nextMeasure();
}
while (m);
push_back(s);
_expanded = false;
}
//---------------------------------------------------------
// unwind
// implements:
// - repeats
// - volta
// - d.c. al fine
// - d.s. al fine
// - d.s. al coda
//---------------------------------------------------------
void RepeatList::unwind()
{
qDeleteAll(*this);
clear();
_voltaRanges.clear();
_jumpsTaken.clear();
Measure* fm = _score->firstMeasure();
if (!fm)
return;
//qDebug("unwind===================");
for (Measure* m = fm; m; m = m->nextMeasure())
m->setPlaybackCount(0);
preProcessVoltas();
MeasureBase* sectionStartMeasureBase = NULL; // NULL indicates haven't discovered starting Measure of section
MeasureBase* sectionEndMeasureBase = NULL;
// partition score by section breaks and unwind individual sections separately
// note: section breaks may occur on non-Measure frames, so must search list of all MeasureBases
for (MeasureBase* mb = _score->first(); mb; mb = mb->next()) {
// unwindSection only deals with real Measures, so sectionEndMeasureBase and sectionStartMeasureBase will only point to real Measures
if (mb->isMeasure()) {
sectionEndMeasureBase = mb; // ending measure of section is the most recently encountered actual Measure
// starting measure of section will be the first non-NULL actual Measure encountered
if (sectionStartMeasureBase == NULL)
sectionStartMeasureBase = mb;
}
// if found section break or reached final MeasureBase of score, then unwind
if (mb->sectionBreak() || !mb->nextMeasure()) {
// only unwind if section starts and ends with actual real measure
if (sectionStartMeasureBase && sectionEndMeasureBase) {
unwindSection(reinterpret_cast<Measure*>(sectionStartMeasureBase), reinterpret_cast<Measure*>(sectionEndMeasureBase));
sectionStartMeasureBase = 0; // reset to NULL to indicate that don't know starting Measure of next section after starting new section
sectionEndMeasureBase = 0;
}
else {
qDebug( "Will not unroll a section that doesn't start or end with an actual measure. sectionStartMeasureBase = %p, sectionEndMeasureBase = %p",
sectionStartMeasureBase, sectionEndMeasureBase);
}
}
}
updateTempo();
_expanded = true;
dump();
}
//---------------------------------------------------------
// preProcessVoltas
// determine the real effective endpoint of voltas
// because an open volta doesn't necessarily end on its end anchorpoint
// MUST be called before unwinding(Section) logic!
//---------------------------------------------------------
void RepeatList::preProcessVoltas()
{
Volta* nextVolta = nullptr; //work backwards as a volta can end because the next one starts
for (auto rit = _score->spanner().crbegin(); rit != _score->spanner().crend(); ++rit)
{
Spanner* s = (*rit).second;
if (!s->isVolta())
continue;
Volta* volta = toVolta(s);
if (volta) {
if (_voltaRanges.find(volta) == _voltaRanges.end()) { // not yet determined the real endpoint, should always be true
// start by assuming the end of the spanner == the end of this volta (closed volta)
Measure* voltaEndMeasure = volta->endMeasure();
// open volta may end past its spanner
if (volta->getProperty(Pid::END_HOOK_TYPE).value<HookType>() == HookType::NONE) {
Measure* nextMeasureToInspect = voltaEndMeasure->nextMeasure();
// open volta ends:
while ( (nextMeasureToInspect) // end of score
&& (!voltaEndMeasure->sectionBreak()) // or end of section
&& (!voltaEndMeasure->repeatEnd()) // hitting an endRepeat
&& (!nextMeasureToInspect->repeatStart()) // or starting a new repeat
&& (!nextVolta || (nextMeasureToInspect != nextVolta->startMeasure())) // or if another volta starts
&& (!voltaEndMeasure->repeatJump()) //or hitting a jump, otherwise the part after the jump might be considered under this volta as well…
) { // nextMeasureToInspect is still part of this volta
voltaEndMeasure = nextMeasureToInspect;
nextMeasureToInspect = voltaEndMeasure->nextMeasure();
}
}
// found the real ending of this volta, store it to minimize search efforts
_voltaRanges.insert(std::pair<Volta*, Measure*>(volta, voltaEndMeasure));
nextVolta = volta; // this volta might indicate the end of the previous one
}
else {
qDebug("Found same volta twice in the spannermap");
}
}
} // end spannerloop
}
//---------------------------------------------------------
// searchVolta
// return the iterator in _voltaRanges for the volta spanning the given measure
//---------------------------------------------------------
std::map<Volta*, Measure*>::const_iterator RepeatList::searchVolta(Measure * const measure) const
{
std::map<Volta*, Measure*>::const_iterator voltaRange;
for (voltaRange = _voltaRanges.cbegin(); voltaRange != _voltaRanges.cend(); ++voltaRange) {
if ( (voltaRange->first->startMeasure()->tick() <= measure->tick())
&& (measure->tick() <= voltaRange->second->tick())
) {
break;
}
}
return voltaRange;
}
//---------------------------------------------------------
// unwindSection
// unwinds from sectionStartMeasure through sectionEndMeasure
//---------------------------------------------------------
void RepeatList::unwindSection(Measure* const sectionStartMeasure, Measure* const sectionEndMeasure)
{
// qDebug("unwind %d-measure section starting %p through %p", sectionEndMeasure->no()+1, sectionStartMeasure, sectionEndMeasure);
if (!sectionStartMeasure || !sectionEndMeasure) {
qDebug("invalid section start/end");
return;
}
RepeatSegment* rs = nullptr; // no measures to be played yet
Measure* prevMeasure = nullptr; // the last processed measure that is part of this RepeatSegment
Measure* currentMeasure = sectionStartMeasure; // the measure to be processed/evaluated
Measure* startFrom = sectionStartMeasure; //the last StartRepeat encountered in this loop; we should return here upon hitting a repeat
int startFromRepeatStartCount = findStartFromRepeatCount(startFrom);
std::map<Volta*, Measure*>::const_iterator voltaRange = _voltaRanges.cend();
Measure* playUntilMeasure = nullptr; // used during jumping
Measure* continueAtMeasure = nullptr; // used during jumping
while (currentMeasure && (currentMeasure != sectionEndMeasure->nextMeasure())) {
if ( (voltaRange != _voltaRanges.cend())
&& (currentMeasure == voltaRange->second->nextMeasure())
) { // volta was active -> not anymore
voltaRange = _voltaRanges.cend();
}
// Should we play or skip this measure: --> look for volta
if (voltaRange == _voltaRanges.cend()) {
voltaRange = searchVolta(currentMeasure);
if ( (voltaRange != _voltaRanges.cend())
&& !voltaRange->first->hasEnding(startFrom->playbackCount())
) {
// volta does not apply for expected playbackCount --> skip it
// but first finalize the current RepeatSegment
if (rs) {
push_back(rs);
rs = nullptr;
}
// now skip the volta
currentMeasure = voltaRange->second->nextMeasure();
voltaRange = _voltaRanges.cend();
// restart processing for the new measure
prevMeasure = nullptr;
continue;
}
}
// include this measure into the current RepeatSegment
currentMeasure->setPlaybackCount(currentMeasure->playbackCount() + 1);
if (nullptr == rs) {
rs = new RepeatSegment();
}
rs->addMeasure(currentMeasure);
prevMeasure = currentMeasure;
if (currentMeasure->repeatStart()) {
// always start from the last encountered repeat
startFrom = currentMeasure;
startFromRepeatStartCount = findStartFromRepeatCount(startFrom);
}
if ( (currentMeasure->repeatEnd())
&& (currentMeasure->playbackCount() < currentMeasure->repeatCount()) // not yet exhausted our number of repeats
) {
// finalize this RepeatSegment
push_back(rs);
rs = nullptr;
// we already know where to start from now, so continue right away with the new reference
currentMeasure = startFrom;
prevMeasure = nullptr;
voltaRange = _voltaRanges.cend();
continue;
}
// we will now check for jumps, these should only be followed upon the last pass through a measure
if ( (startFrom->playbackCount() == startFromRepeatStartCount) // means last pass through this set of repeats
|| ( (voltaRange != _voltaRanges.cend())
&& (startFrom->playbackCount() == voltaRange->first->lastEnding()) // or last pass through this volta
)
) {
if (currentMeasure->repeatJump()) { // found a jump, should we follow it?
// fetch the jump
Jump* jump = nullptr;
for (Element* e : currentMeasure->el()) {
if (e->isJump()) {
jump = toJump(e);
break;
}
}
// have we processed it already?
if (_jumpsTaken.find(jump) == _jumpsTaken.end()) { // not yet processed
// processing it now
_jumpsTaken.insert(jump);
// validate the jump
Measure* jumpToMeasure = _score->searchLabelWithinSectionFirst(jump->jumpTo(), sectionStartMeasure, sectionEndMeasure);
playUntilMeasure = _score->searchLabelWithinSectionFirst(jump->playUntil(), sectionStartMeasure, sectionEndMeasure);
continueAtMeasure = _score->searchLabelWithinSectionFirst(jump->continueAt(), sectionStartMeasure, sectionEndMeasure);
if (jumpToMeasure && playUntilMeasure && (continueAtMeasure || jump->continueAt().isEmpty())) {
// we will jump, but first finalize the current RepeatSegment
push_back(rs);
rs = nullptr;
// now jump
// basically, replay the score from jumpToMeasure all the way up the to last occurrence of playUntilMeasure
// this replay lookup uses mostly indexes over iterators as push_back of new segments might invalidate an iterator
// step 1: find the last occurrence of playUntilMeasure
Measure* copyUntilMeasure = playUntilMeasure; // assume we can rewind back to the playUntilMeasure
int copyUntilIdx = this->size() - 1; // assume we will find the copyUntilMeasure in the (currently) last repeatSegment
int playUntilIdx = this->size();
do {
--playUntilIdx;
}
while ( (!(this->at(playUntilIdx)->containsMeasure(playUntilMeasure)))
&& (playUntilIdx > 0)
);
if (isFinalPlaythrough(playUntilMeasure, (this->cbegin() + playUntilIdx))) {
copyUntilIdx = playUntilIdx;
}
else { // not found or not final playthrough
// -> currentMeasure is the most recent parsed measure that should be included into the replay
copyUntilMeasure = currentMeasure;
}
// step 2: find jumpToMeasure
auto copyFromIdx = -1;
Measure * copyFromMeasure = jumpToMeasure;
if (jump->playRepeats()) {
// we want to replay as much from the score as possible
// => find most recent occurrence of first playBack of jumpToMeasure #270332
for (int jumpToIdx = playUntilIdx; jumpToIdx >= 0; --jumpToIdx) {
if (this->at(jumpToIdx)->playbackCount(jumpToMeasure) == 1) {
copyFromIdx = jumpToIdx;
break;
}
}
}
else { // no repeats upon jumping => find final occurrence of jumpToMeasure
int jumpToIdx = this->size();
do {
--jumpToIdx;
}
while ( (!(this->at(jumpToIdx)->containsMeasure(jumpToMeasure)))
&& (jumpToIdx > 0)
);
if (isFinalPlaythrough(jumpToMeasure, (this->cbegin() + jumpToIdx))) {
copyFromIdx = jumpToIdx;
}
}
// step 3 : duplicate the part we would otherwise have to rewind
if (copyFromIdx != -1) {
if (jump->playRepeats()) {
// all should be replayed, simply copy over
for (int idx = copyFromIdx; idx <= copyUntilIdx; ++idx) {
this->push_back(new RepeatSegment(
this->at(idx),
(idx == copyFromIdx) ? copyFromMeasure : nullptr,
(idx == copyUntilIdx) ? copyUntilMeasure : nullptr
)
);
}
}
else { // only most recent passes should be played
// so we have to inspect each measure to be it's most recent playthrough
int idx = copyFromIdx;
while (idx <= copyUntilIdx) {
RepeatSegment* referenceSegment = this->at(idx);
auto referenceIt = referenceSegment->measureList.cbegin();
bool forwardToMoreRecentPlaythrough = false;
if (idx == copyFromIdx) {
// skip start of segment
while ((referenceIt->first != copyFromMeasure) && ((++referenceIt) != referenceSegment->measureList.cend()));
}
// start copy
while ( ((referenceIt != referenceSegment->measureList.cend()) && !forwardToMoreRecentPlaythrough)
&& ((idx != copyUntilIdx) || (referenceIt->first->no() <= copyUntilMeasure->no()))
) {
// find most recent occurrence of this measure
auto mostRecentRepeatSegmentIdx = copyUntilIdx; // look backwards to find to most recent first
while ((mostRecentRepeatSegmentIdx > idx) && !forwardToMoreRecentPlaythrough) {
RepeatSegment * mostRecentSegment = this->at(mostRecentRepeatSegmentIdx);
if ( (mostRecentSegment->playbackCount(referenceIt->first) >= referenceIt->second)
&& (referenceIt->first->no() <= copyUntilMeasure->no())
) {
// found a more recent playthrough => continue our copy from there
forwardToMoreRecentPlaythrough = true;
// save continueCopyPosition
copyFromMeasure = referenceIt->first;
idx = mostRecentRepeatSegmentIdx;
continue;
}
--mostRecentRepeatSegmentIdx;
}
if (!forwardToMoreRecentPlaythrough) {
// this is the most recent playthrough of this measure -> copy it
if (nullptr == rs) {
rs = new RepeatSegment();
rs->tick = referenceIt->first->tick().ticks();
}
rs->measureList.push_back(std::make_pair(referenceIt->first, referenceIt->second));
}
// test & copy next measure
++referenceIt;
}
// store what we've copied from this repeatSegment
if (rs) {
push_back(rs);
rs = nullptr;
}
// move to the next repeatSegment
if (!forwardToMoreRecentPlaythrough) {
++idx;
}
}
}
}
// step 4 : determine the next measure to evaluate
if (copyFromIdx == -1) {
// still everything to process, because we couldn't copy from the jumpToMeasure yet
currentMeasure = jumpToMeasure; // so start there now
}
else {
if (copyUntilMeasure == playUntilMeasure) {
// fully processed this jump, we know where to continue, so jump there
currentMeasure = continueAtMeasure;
// end of processing this jump
playUntilMeasure = nullptr;
continueAtMeasure = nullptr;
}
else {
// we have copied stuff, but not yet all of it
currentMeasure = copyUntilMeasure->nextMeasure();
}
}
if (currentMeasure) {
startFrom = findStartRepeat(currentMeasure); // not yet happy with these, but not worse than before
startFromRepeatStartCount = findStartFromRepeatCount(startFrom);
}
// restart processing
prevMeasure = nullptr;
voltaRange = _voltaRanges.cend();
continue;
}
}
}
if (currentMeasure == playUntilMeasure) {
// end of processing this jump
playUntilMeasure = nullptr;
// finalize the current RepeatSegment
push_back(rs);
rs = nullptr;
// we know where to continue, so jump there
currentMeasure = continueAtMeasure;
continueAtMeasure = nullptr;
// restart processing
prevMeasure = nullptr;
voltaRange = _voltaRanges.cend();
continue;
}
}
// keep looping until reach end of score or end of the section
currentMeasure = currentMeasure->nextMeasure();
}
// append the final repeat segment of that section
if (rs) {
if (prevMeasure) {
if (rs->len()) {
push_back(rs);
rs = nullptr;
}
else
delete rs;
}
else // not even a single measure included in the segment -> it is empty
delete rs;
}
}
//---------------------------------------------------------
// findStartRepeat
// search backwards starting at a given measure to find a repeatStart
// @return the measure having the repeatStart or start of section
//---------------------------------------------------------
Measure* RepeatList::findStartRepeat(Measure * const measure) const
{
Measure* m = measure;
while ((!m->repeatStart())
&& (m != _score->firstMeasure())
&& (!m->prevMeasure()->sectionBreak()))
{
m = m->prevMeasure();
}
return m;
}
//---------------------------------------------------------
// findStartFromRepeatCount
// @param startFrom starting measure for this repeat subsection
// @return number of times playback passes the start repeat barline (not accounting for jumps)
//---------------------------------------------------------
int RepeatList::findStartFromRepeatCount(Measure * const startFrom) const
{
Measure * m = startFrom;
int startFromRepeatCount = (m->repeatEnd())? (m->repeatCount()) : 1;
m = m->nextMeasure();
while (m && !m->repeatStart()) {
if (m->repeatEnd()) {
startFromRepeatCount += m->repeatCount() - 1;
}
m = (m->sectionBreak()) ? nullptr : m->nextMeasure();
}
return startFromRepeatCount;
}
//---------------------------------------------------------
// isFinalPlaythrough
// @param measure the measure to verify
// @param repeatSegment consider measure with its playbackCount in this specific RepeatSegment
// @return true if that measure has its final playthrough in the given repeatSegment
//---------------------------------------------------------
bool RepeatList::isFinalPlaythrough(Measure * const measure, QList<RepeatSegment*>::const_iterator repeatSegmentIt) const
{
bool finalPlaythrough = false;
if ( (repeatSegmentIt != this->cend())
&& ((*repeatSegmentIt)->containsMeasure(measure))
) {
// step 1 : so go and look back for the relevant startRepeatMeasure
Measure * startRepeatMeasure = findStartRepeat(measure);
auto startRepeatIt = repeatSegmentIt;
while ( (startRepeatIt != this->cbegin())
&& (!(*startRepeatIt)->containsMeasure(startRepeatMeasure))
){
--startRepeatIt;
}
int startRepeatPlaybackCount = (*startRepeatIt)->playbackCount(startRepeatMeasure);
// step 2 : does this measure belong to a volta?
auto voltaRange = searchVolta(measure);
// step 3 : is it the final playThrough of this measure?
if ( (startRepeatPlaybackCount == findStartFromRepeatCount(startRepeatMeasure))
|| ( (voltaRange != _voltaRanges.cend())
&& (startRepeatPlaybackCount == voltaRange->first->lastEnding())
)
) {
finalPlaythrough = true;
}
//else: found, but not yet final playthrough -> nothing to do
}
//else: measure not found == not part of this RepeatSegment -> nothing to do
return finalPlaythrough;
}
}
↑ V1042 This file is marked with copyleft license, which requires you to open the derived source code.


We sell metrics!
- unleash synergistic e-markets
- grow world-class systems
- revolutionize plug-and-play platforms
- mesh magnetic initiatives
- benchmark B2B applications
- facilitate extensible architectures
- disintermediate granular deliverables
- empower world-class experiences
- innovate end-to-end partnerships
- reintermediate web-enabled functionalities
- incentivize revolutionary channels
- engineer out-of-the-box markets
- empower intuitive technologies
- architect strategic interfaces


About:
{{speaker?.about}}
Date & Time:
{{speaker?.time}}
Look for more events on Teeny Tiny Explorers Social Media Pages!
Contact:


I've been employed with P&G in Iowa City since 2007.
My current title is Supplier Quality Leader. In this role, I work as the SPOC (single point of contact) between the production lines and the plant's material suppliers. I facilitate loss elimination teams within the plant to drive out losses that the lines thought were related to material quality. I also help suppliers drive out loss through their company's root cause analysis tools.
Explained poorly, people complain at me about materials, I pick a person to side with, and then complain at the other until they fix the problem.


To cast a vote, select both an election and a voter
For more about this voting system, see the introduction


Ingredients List
- 3/4 cup milk
- 2 tablespoons white vinegar
- 1/2 teaspoon baking soda
- 1/2 teaspoon salt
- 1 cup all-purpose flour
- 1 egg
- 2 tablespoons white sugar
- 1 teaspoon baking powder
- 2 tablespoons butter melted
- cooking spray
Directions
- Combine milk with vinegar in a medium bowl and set aside for 5 minutes to "sour".
- Combine flour, sugar, baking powder, baking soda, and salt in a large mixing bowl. Whisk egg and butter into "soured" milk. Pour the flour mixture into the wet ingredients and whisk until lumps are gone.
- Heat a large skillet over medium heat, and coat with cooking spray. Pour 1/4 cupfuls of batter onto the skillet, and cook until bubbles appear on the surface. Flip with a spatula, and cook until browned on the other side.
Game Directions
- use your keyboard direction to move around .
- Collect the to discover the ingredients and directions to cook fluffy pancakes.
- When the appears collect it to kill some bugs and slow the other ones.
- To start Playing the game press the space key on your keyboard.


tidytable helpers |
|
|---|---|
data.table::fcase() with vectorized default |
|
Pipeable data.table call |
|
Convert character and factor columns to dummy variables |
|
notin operator |
|
dplyr |
|
Core dplyr verbs |
|
Arrange/reorder rows |
|
Filter rows on one or more conditions |
|
Add/modify/delete columns |
|
Select or drop columns |
|
Aggregate data using summary statistics |
|
Other dplyr functions |
|
Apply a function across a selection of columns |
|
Arrange by a selection of variables |
|
Do the values from x fall between the left and right bounds? |
|
Bind data.tables by row and column |
|
Combine values from multiple columns |
|
Case when |
|
Coalesce missing values |
|
Count observations by group |
|
Current group context |
|
Descending order |
|
Select distinct/unique rows |
|
Split data frame by groups |
|
Create conditions on a selection of columns |
|
Fast ifelse |
|
Get lagging or leading values |
|
|
|
Join two data.tables together |
Mutate multiple columns simultaneously |
|
Add/modify columns by row |
|
Number of observations in each group |
|
Count the number of unique values in a vector |
|
Nest data.tables |
|
Pull out a single variable |
|
Relocate a column to a new position |
|
Rename variables by name |
|
Rename multiple columns |
|
Return row number |
|
|
|
Choose rows in a data.table |
Summarize multiple columns |
|
Add new variables and drop all others |
|
tidyr |
|
Complete a data.table with missing combinations of data |
|
Create a data.table from all unique combinations of inputs |
|
Drop rows containing missing values |
|
Expand a data.table to use all combinations of values |
|
Create a data.table from all combinations of inputs |
|
Extract a character column into multiple columns using regex |
|
Fill in missing values with previous or next value |
|
Nest data.tables |
|
Pivot data from wide to long |
|
Pivot data from long to wide |
|
Replace missing values |
|
Separate a character column into multiple columns |
|
Separate a collapsed column into multiple rows |
|
Uncount a data.table |
|
Unite multiple columns by pasting strings together |
|
Unnest a nested data.table |
|
purrr |
|
|
|
Apply a function to each element of a vector or list |
reexportsThese functions are reexported from |
|
Objects exported from other packages |
|
tidytable constructors
A tidytable is simply a data.table with nice printing features. Note: All tidytable functions automatically convert data.frame/tibble inputs to a data.table/tidytable. |
|
Coerce an object to a data.table/tidytable |
|
Test if the object is a tidytable |
|
Build a data.table/tidytable |


I am graduate student pursuing Master's in Software Engineering at New Jersey Institute of Technology
"Education is the most powerful weapon which you can use to change the world"
"-Nelson Mandela"
Aug 2016 - Dec 2017
Master's in Software Engineering, GPA: 3.83/4.0
Course Work:- Software Testing and Quality Assurance, Software Architecture, Database System Analysis Design, Operating Systems, Software Project management, User Experience Design.
.. New Jersey, United StatesAug 2009 - May 2013
Bachelor's in Electronics and Communication Engineering GPA: 7.918/10
Course Work:- Computer Practice, Engineering Mathematics, Digital Systems, Network Simulation, Digital Signal Processing, Discrete Mathematics, Probability and Random Processes, Business Management, MATLAB, Digital Communication
.. Chennai, India
"Nothing Ever becomes real till it experienced."
"-John Keats"
Aug 2014 - Aug 2016
Worked on Predictive Marketing Analytics-R & D project for global clients across different industries (telecommunication, retail and marketing). Responsibilities included test planning, preparation, design and execution with agile methodology for multiple sprints and releases. Involved in analyzing client requirements and structuring use cases into respective test scenarios and user stories. Delivered QA reports to different stakeholders using agile project management tool-JIRA. Also worked on performance testing using load runner for transition of big data frameworks from Hadoop to Apache Spark. Was a Subject matter expert for optimization-SAS and Lego engines and also responsible for providing Knowledge transfer within offshore teams.
.. Gurgaon, IndiaAug 2013 - July 2014
Was a part of the QA team for Duck creek Technologies where I worked for Prosight Insurance, USA Client and was responsible for test plan creation, test cases and script creation and UAT execution for the forms for multiple Line of Business (LOB’s).
.. Mumbai, IndiaMarch 2013 - Aug 2013
Worked on Duck Creek Technology Projects for AIG-Chartis and Zurich client as a Software Engineering Intern and was mainly involved in the testing of policy forms for various Line of Businesses.
.. Mumbai, IndiaImplemented Analyzed the entire library database application and came up with an extended entity relationship diagram and mapped the diagram to relational schema along with Key constraints, Entity integrity constraints, and Referential integrity constraints. Finally created a database schema and interfaced using PHP and HTML-5.
Designed a fully working interactive prototype of a rating application called “Mello” which is used for rating professors. I used a rapid wire framing and prototyping software tool called Axure RP 8 which aims at web and desktop applications. Involved in full research of personas, created root concept tables, Problem scenario and Storyboard, activity scenario and finally full-fledged working prototype key path scenario.
Mello App Project• Full Stack Developer in the project. Implemented the application on HTML-5, CSS, JavaScript, Bootstrap for front-end and Java being the Backend Coding along with My-SQL for Database which contained details related to patients, doctors and the list of diseases and symptoms.
• Executed Naive Bayes Algorithm for the Prediction of diseases and used J-unit for Unit testing.
• Performed system testing and integration testing using selenium.
• Designed and developed multiple architecture views of a speed control application involving Logical, Process, Development and Physical view using the Internet of Things (IoT) platform. • Analyzed and developed the appropriate architectural approach and structure for various technical, business and product situations.
Personal Email-<EMAIL_ADDRESS>NJIT Email-<EMAIL_ADDRESS>Site Under Construction


- SagaBattlegroundTest - Class in com.example.littleync
-
- SagaBattlegroundTest() - Constructor for class com.example.littleync.SagaBattlegroundTest
-
- sagaBattlegroundTest() - Method in class com.example.littleync.SagaBattlegroundTest
-
- SagaBattlegroundTimerActivity - Class in com.example.littleync.gameActivities
-
Saga Battleground Activity page where the user can idly battle monsters to gain gold resource
- SagaBattlegroundTimerActivity() - Constructor for class com.example.littleync.gameActivities.SagaBattlegroundTimerActivity
-
Sets the tag for the Log
- scrollParent - Variable in class com.example.littleync.gameActivities.MarketplaceActivity
-
- sellQty - Variable in class com.example.littleync.gameActivities.MarketplaceActivity
-
- sellQty - Variable in class com.example.littleync.model.Trade
-
- sellType - Variable in class com.example.littleync.model.Trade
-
- sellTypeStr - Variable in class com.example.littleync.gameActivities.MarketplaceActivity
-
- setAggregateLevel(int) - Method in class com.example.littleync.model.User
-
- setCombatGearLevel(int) - Method in class com.example.littleync.model.User
-
- setCombatUpgrade() - Method in class com.example.littleync.gameActivities.ArmoryActivity
-
To set the TextView displays relevant to upgrading the upgrading the combat gear
- setDocumentID(String) - Method in class com.example.littleync.model.Trade
-
- setExp(int) - Method in class com.example.littleync.model.User
-
- setFish(int) - Method in class com.example.littleync.model.User
-
- setFishingGearLevel(int) - Method in class com.example.littleync.model.User
-
- setFishUpgrade() - Method in class com.example.littleync.gameActivities.ArmoryActivity
-
To set the TextView displays relevant to upgrading the upgrading the fishing gear
- setGold(int) - Method in class com.example.littleync.model.User
-
- setReceiveQty(int) - Method in class com.example.littleync.model.Trade
-
- setReceiveType(String) - Method in class com.example.littleync.model.Trade
-
- setSellQty(int) - Method in class com.example.littleync.model.Trade
-
- setSellType(String) - Method in class com.example.littleync.model.Trade
-
- setTimeOfListing(String) - Method in class com.example.littleync.model.Trade
-
- settingContentView() - Method in class com.example.littleync.gameActivities.ArmoryActivity
-
Sets the correct content view
- settingContentView() - Method in class com.example.littleync.gameActivities.AttributesActivity
-
Sets the correct content view for the abstract class implementing, called in onCreate()
- settingContentView() - Method in class com.example.littleync.gameActivities.CendanaForestTimerActivity
-
Sets the correct content view
- settingContentView() - Method in class com.example.littleync.gameActivities.EcopondTimerActivity
-
Sets the correct content view
- settingContentView() - Method in class com.example.littleync.gameActivities.SagaBattlegroundTimerActivity
-
Sets the correct content view
- setTrades(ArrayList<String>) - Method in class com.example.littleync.model.User
-
- setUp() - Method in class com.example.littleync.EcopondActivityTest
-
- setUp() - Method in class com.example.littleync.model.ShopTest
-
- setUp() - Method in class com.example.littleync.model.UserTest
-
- setUserName(String) - Method in class com.example.littleync.model.Trade
-
- setUserName(String) - Method in class com.example.littleync.model.User
-
- setWood(int) - Method in class com.example.littleync.model.User
-
- setWoodchoppingGearLevel(int) - Method in class com.example.littleync.model.User
-
- setWoodUpgrade() - Method in class com.example.littleync.gameActivities.ArmoryActivity
-
To set the TextView displays relevant to upgrading the upgrading the woodchopping gear
- SHOP - Variable in class com.example.littleync.gameActivities.ArmoryActivity
-
- Shop - Class in com.example.littleync.model
-
Shop object that is created only for the Armory Activity, providing some useful methods for the
User to upgrade their gear
- Shop() - Constructor for class com.example.littleync.model.Shop
-
- ShopTest - Class in com.example.littleync.model
-
- ShopTest() - Constructor for class com.example.littleync.model.ShopTest
-
- showToast(String) - Method in class com.example.littleync.gameActivities.MarketplaceActivity
-
Convenient method that properly formats then displays a toast message
- signIn() - Method in class com.example.littleync.LoginActivity
-
signIn() method sends a signin request to firebase, and returns the results of the attempt.
- signUp(View) - Method in class com.example.littleync.LoginActivity
-
- SignupActivity - Class in com.example.littleync
-
Class which determines the logic for the signup page.
- SignupActivity() - Constructor for class com.example.littleync.SignupActivity
-
- signUpSubmit(View) - Method in class com.example.littleync.SignupActivity
-
signUpSubmit is the button which is linked to the signup button on the signup page.
- SplashScreen - Class in com.example.littleync
-
- SplashScreen() - Constructor for class com.example.littleync.SplashScreen
-
- staminaDisplay - Variable in class com.example.littleync.gameActivities.ActionTimerActivity
-
- startPauseResumeBtn - Variable in class com.example.littleync.gameActivities.ActionTimerActivity
-
- startTimer() - Method in class com.example.littleync.gameActivities.ActionTimerActivity
-
Begins the timer counting down
- submitSignUp - Variable in class com.example.littleync.SignupActivity
-
- synchronizeLocations(TreeMap<String, Boolean>, TreeMap<String, Boolean>) - Method in class com.example.littleync.LoginActivity
-
SynchronizeLocations updates whereAmINowMap with whereWasIMap and ensures that both the maps are identical.


CONTINUE?
RELOAD
ADD INITIALS
INITIALS:
ADD
SCORE :
HIGH SCORES


Keyboard © 2020 SIL International
Duun language Unicode keyboard to type all special characters on a QWERTY keyboard.
Langue Duun Clavier Unicode pour QWERTY incl caractères speciaux.
This keyboard outputs mostly precomposed (NFC) Unicode characters. However, please be aware that it is not completely NFC. Also, not all of the NFC characters will be on the mobile longpress keys. If they are not available as precomposed characters, you may have to type the vowel followed by the diacritic (which is on a special diacritic key next to the spacebar).


The standard remote protocol is a simple, packet based scheme. A debug packet whose contents are <data> is encapsulated for transmission in the form:
$ <data> # CSUM1 CSUM2
<data> must be ASCII alphanumeric and cannot include characters
$
or #
. If <data> starts with two characters
followed by :
, then the existing stubs interpret this as a
sequence number. For example, the command g
is used to read the
values of the registers. So, a packet to do this would look like
$g#67
CSUM1 and CSUM2 are an ascii representation in hex of an 8-bit checksum of <data>, the most significant nibble is sent first. the hex digits 0-9,a-f are used.
A simple protocol is used when communicating with the target. This is
mainly to give a degree of error handling over the serial cable. For
each packet transmitted successfully, the target responds with a
+
(ACK
). If there was a transmission error, then the target
responds with a -
(NAK
). An error is determined when the
checksum doesn't match the calculated checksum for that data record.
Upon reciept of the ACK
, GDB
can then transmit the next
packet.
Here is a list of the main functions that need to be supported. Each data
packet is a command with a set number of bytes in the command packet.
Most commands either return data, or respond with a NAK
. Commands
that don't return data respond with an ACK
. All data values are
ascii hex digits. Every byte needs two hex digits to represent t. This
means that a byte with the value ‘7’ becomes ‘07’. On a 32 bit
machine this works out to 8 characters per word. All of the bytes in a
word are stored in the target byte order. When writing the host side of
the GDB protocol, be careful of byte order, and make sure that the code
will run on both big and little endian hosts and produce the same answers.
These functions are the minimum required to make a GDB backend work. All other commands are optional, and not supported by all GDB backends.
g
’XXXXXXXX...
Registers are in the internal order for GDB, and the bytes in a register
are in the same order the machine uses. All values are in sequence
starting with register 0. All registers are listed in the same packet. A
sample packet would look like $g#
.
GXXXXXXXX...
’XXXXXXXX
is the value to set the register to. Registers are in
the internal order for GDB, and the bytes in a register are in the same
order the machine uses. All values are in sequence starting with
register 0. All registers values are listed in the same packet. A sample
packet would look like $G000000001111111122222222...#
returns ACK
or NAK
mAAAAAAAA,LLLL
’AAAAAAAA
is address, LLLL
is length. A sample packet would
look like $m00005556,0024#
. This would request 24 bytes starting
at address 00005556
returns XXXXXXXX...
XXXXXXXX
is the memory contents. Fewer bytes than requested will
be returned if only part of the data can be read. This can be determined
by counting the values till the end of packet #
is seen and
comparing that with the total count of bytes that was requested.
MAAAAAAAA,LLLL:XXXXXXXX
’AAAAAAAA
is the starting address, LLLL
is the number of
bytes to be written, and XXXXXXXX
is value to be written. A
sample packet would look like
$M00005556,0024:101010101111111100000000...#
returns ACK
or NAK
for an error. NAK
is also
returned when only part of the data is written.
cAAAAAAAAA
’AAAAAAAA
is address to resume execution at. If AAAAAAAA
is
omitted, resume at the curent address of the pc
register.
returns the same replay as last signal
. There is no immediate
replay to cont
until the next breakpoint is reached, and the
program stops executing.
AA..AA
is address to resume
If AA..AA
is omitted, resume at same address.
returns the same replay as last signal
. There is no immediate
replay to step
until the next breakpoint is reached, and the
program stops executing.
?
’SAA
Where AA
is the number of the last signal.
Exceptions on the target are converted to the most similar Unix style
signal number, like SIGSEGV
. A sample response of this type would
look like $S05#
.
AA
is the signal number.
nn
is the register number.
XXXXXXXX
is the register value.
AA
is the exit status. This is only
applicable for certains sorts of targets.
These are used in some GDB backends, but not all.
Pnn=XXXXXXXX
’nn
with value XXXXXXXX
.
returns ACK
or NAK
other
’$#<checksum>
. This way we can extend the protocol and GDB
can tell whether the stub it is talking to uses the old or the new.
tAA:PP,MM
’AA
for a match with pattern
PP and mask MM
. PP
and MM
are 4 bytes.
qXXXX
’QXXXX=yyyy
’XXXX
to yyyy
.
qOffsets
’Text=xxx;Data=yyy;Bss=zzz
Responses can be run-length encoded to save space. A *
means that
the next character is an ASCII encoding giving a repeat count which
stands for that many repetitions of the character preceding the *
.
The encoding is n+29, yielding a printable character where n >=3
(which is where run length encoding starts to win). You can't use a
value of where n >126 because it's only a two byte value. An example
would be a 0*03
means the same thing as 0000
.


Just 46% Are Wholly Comfortable With Female Political Leaders
by Lucy Meakin1 / 3
(Bloomberg) -- Explore what’s moving the global economy in the new season of the Stephanomics podcast. Subscribe via Apple Podcast, Spotify or Pocket Cast.
Discomfort with female leadership in politics and business remains widespread, with less than half of people in Group of Seven nations fully at ease with a woman running their government or a major company, a study published Tuesday shows.
On average in the G-7, just 46% of society is “very comfortable” with a woman as head of government and 48% with a female CEO of a major national firm, according to a survey by Kantar and the Women Political Leaders group. That indicates some level of discomfort among the rest of respondents, they said.
The data, based on a survey of 22,000 people across 11 countries, suggest that there’s not necessarily a correlation between public attitudes and women’s ascension to power. Canada, which ranked top, has only had one female head of government. In the U.S., which was third most comfortable with a woman in charge, some polls have indicated that potential Democratic candidate Elizabeth Warren’s gender could be a concern for voters ahead of the 2020 election.
Conversely, with Angela Merkel just days from completing her 14th year as German chancellor, less than one-third of those surveyed in her country said they were fully at ease with a woman in the role.
In the U.K., the proportion who said men and women are equally suited to both business and political leadership dropped in the past year -- a period that saw Prime Minister Theresa May step down. That change was entirely due to a drop in the number of male respondents who agreed with the view.
To contact the reporter on this story: Lucy Meakin in London at<EMAIL_ADDRESS>To contact the editors responsible for this story: Paul Gordon at<EMAIL_ADDRESS>David Goodman, Zoe Schneeweiss
For more articles like this, please visit us at bloomberg.com
©2019 Bloomberg L.P.


--- layout: post title: Capitalism at its finest date: '2015-06-12T18:30:54+02:00' categories: - Storyboards picture_url: https://film-Storyboards.tumblr.com/post/121384443772 ---


1 write to _continuous
Microsoft.PowerShell.Commands.Diagnostics (1)
GetCounterCommand.cs (1)
129
set {
_continuous
= value; }
1 reference to _continuous
Microsoft.PowerShell.Commands.Diagnostics (1)
GetCounterCommand.cs (1)
127
get { return
_continuous
; }


Thanks for your order!
We appreciate your business! If you have any questions, please email
<EMAIL_ADDRESS>.
Go Home


The Athletic: Manchester City won't be banned from the Champions League
The English media outlet claim regardless of UEFA's findings from the FFP investigations, Guardiola's side won't be thrown out of the competition
by Pol BallúsManchester City won't be banned from competing in the Champions League according to English media outlet The Athletic. Instead of being thrown out of Europe's elite competition, the most City can expect is to be hit with a fine.
The official verdict of the investigation will be revealed within the next month or two. UEFA created the Financial Fair Play regulations in 2009 in order to control and protect clubs from only being able to spend what they earned and could afford to.
LaLiga chief Javier Tebas has made his thoughts clear on the likes of City and PSG bypassing the rules in order to have an unfair advantage. Both of those mentioned teams have been fined in the past for previous infractions.
The current investigation is related to sponsorship money brought in by companies which have links to the City owner. Rivals have accused the club of receiving above market value deals to offset excessive spending.
This information came to light after City's email accounts were hacked.


Spelunk! Amazing Caves (2-D Large Format)
By Ross Anthony
"Amazing Caves" is not an exciting enough title for a sometimes breathtaking, sometimes wondrous audiovisual experience.
The filmmakers take full advantage of this sensational medium to carry us with them to places God knows we'd never go ourselves: winding through the canyons in the Arizona desert, submerged underground, underwater, or dropping through huge ice crevices - climbing, paddling and swimming into mysterious, elusive holes in the Earth.
Though the production pays due attention to education, the beauty and adventure of these journeys are gladly the main focus. Splendid visuals are backed up with warm fertile moody tunes from 60's rock band the Moody Blues. The band reworks (and improves) old favorites for the score, enjoying the grand performance of Large Format audio.
Like exploring a hole itself, the film takes an excursion from the familiar beaten path of documentary format in favor of finding something spiritual to bring home in the specimen jar. Sweetly done.
"The most dangerous part of caving ... is just getting to them."
Cavers take to kayaks and drop down a 12-foot waterfall - your heart and jaw will drop with them. A copter'd cam scraps the pastel canyon walls over a limestone turquoise blue river - gorgeous (no pun intended).
Later in an underwater cave, divers squirm through holes no larger than a pizza. The screen is huge, but a fantastic feeling of claustrophobia squeezes it to within an inch of a gasp. How did they get that huge camera through?
My only suggestions lie within the realm of education. I wouldn't change a single edit on the current production, but might have added graphic overlays to back up some of the narrative. Liam Neeson's tongue gives appropriate potency to the voice-over; but several times technical phrases could have been illustrated in one corner of that huge screen by a chart, diagram or animation, while the big adventure continued. Such overlays would serve to make the production so rich with information viewers will want to see it twice or three times.
Nine years in the making, "Amazing Caves" was well worth the effort. I'd have chosen a better title though ... perhaps: "Caving in", "Climbing into the Earth", "Climbing into Ice, Rock and Water", or my personal favorite: "Spelunk!"
Amazing Caves (2-D Large Format). Copyright © 2001. * Starring Cavers: Hazel Barton and Nancy Aulenbach. * Narrator: Liam Neeson. * Music: The Moody Blues * Directed by Stephen Judson. * Written by Jack Stephens. * Produced by Greg MacGillivray, Stephen Judson, Alec Lorimore.
Grade..........................A
-- Copyright © 2000. Ross Anthony, currently based in Los Angeles, has scripted and shot documentaries, music videos, and shorts in 35 countries across North America, Europe, Africa and Asia.
For more reviews visit: http://www.RossAnthony.com
>From<EMAIL_ADDRESS>Mon Mar 5 19:01:10 PST 2001
by maxwell.ee.washington.edu (8.9.3 (PHNE_18979)/8.9.3) with ESMTP id TAA26581
for
Spelunk! Amazing Caves (2-D Large Format)
By Ross Anthony
"Amazing Caves" is not an exciting enough title for a sometimes breathtaking, sometimes wondrous audiovisual experience.
The filmmakers take full advantage of this sensational medium to carry us with them to places God knows we'd never go ourselves: winding through the canyons in the Arizona desert, submerged underground, underwater, or dropping through huge ice crevices - climbing, paddling and swimming into mysterious, elusive holes in the Earth.
Though the production pays due attention to education, the beauty and adventure of these journeys are gladly the main focus. Splendid visuals are backed up with warm fertile moody tunes from 60's rock band the Moody Blues. The band reworks (and improves) old favorites for the score, enjoying the grand performance of Large Format audio.
Like exploring a hole itself, the film takes an excursion from the familiar beaten path of documentary format in favor of finding something spiritual to bring home in the specimen jar. Sweetly done.
"The most dangerous part of caving ... is just getting to them."
Cavers take to kayaks and drop down a 12-foot waterfall - your heart and jaw will drop with them. A copter'd cam scraps the pastel canyon walls over a limestone turquoise blue river - gorgeous (no pun intended).
Later in an underwater cave, divers squirm through holes no larger than a pizza. The screen is huge, but a fantastic feeling of claustrophobia squeezes it to within an inch of a gasp. How did they get that huge camera through?
My only suggestions lie within the realm of education. I wouldn't change a single edit on the current production, but might have added graphic overlays to back up some of the narrative. Liam Neeson's tongue gives appropriate potency to the voice-over; but several times technical phrases could have been illustrated in one corner of that huge screen by a chart, diagram or animation, while the big adventure continued. Such overlays would serve to make the production so rich with information viewers will want to see it twice or three times.
Nine years in the making, "Amazing Caves" was well worth the effort. I'd have chosen a better title though ... perhaps: "Caving in", "Climbing into the Earth", "Climbing into Ice, Rock and Water", or my personal favorite: "Spelunk!"
Amazing Caves (2-D Large Format). Copyright © 2001. * Starring Cavers: Hazel Barton and Nancy Aulenbach. * Narrator: Liam Neeson. * Music: The Moody Blues * Directed by Stephen Judson. * Written by Jack Stephens. * Produced by Greg MacGillivray, Stephen Judson, Alec Lorimore.
Grade..........................A
-- Copyright © 2000. Ross Anthony, currently based in Los Angeles, has scripted and shot documentaries, music videos, and shorts in 35 countries across North America, Europe, Africa and Asia.
For more reviews visit: http://www.RossAnthony.com
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Van Gisbergen wins Newcastle opener as Whincup throws away Red Bull one-two
by James PaveyShane van Gisbergen continued the Red Bull Holden Racing Team’s good form from the enduros to convert pole to victory in Race 31 at the Coates Hire Newcastle 500.
It loomed to be a sparkling Saturday for the factory Holden squad as Jamie Whincup held second behind van Gisbergen for much of the race, before he made a critical late error to hand P2 to champion-elect Scott McLaughlin.
Whincup’s error cost RBHRT valuable ground as the Holden outfit looks to steal the teams’ championship away from the Shell V-Power Racing Team.
Stream the 2019 Coates Hire Newcastle 500. Live & Ad-Break Free During Racing on KAYO SPORTS. Get your 14 day free trial >
READ MORE
Drama: McLaughlin in ‘difficult position’ but urged to focus on results
10th to pole! First-man-out van Gisbergen snatches P1 in Newcastle
J-Dub P1: Whincup tops hectic Newcastle qualifying as ill Pye finds the wall
‘I love banter, but that’s s**t’: Instagram spat triggers Supercars intervention
Van Gisbergen escorted McLaughlin wide at the first turn after the start, helping Whincup slot into second to complete a RBHRT quinella.
As van Gisbergen held firm, Whincup kept the #97 honest as McLaughlin retained station in third. The champion was brought in on Lap 7 and was short-fuelled, and once Whincup (Lap 16) and van Gisbergen stopped (Lap 33), McLaughlin emerged in the lead.
Van Gisbergen, having taken a longer stop, dropped to third but quickly caught the rear of his teammate’s ZB Commodore, with McLaughlin unable to create a gap.
On Lap 43, Whincup moved aside to let van Gisbergen through into Turn 11, and the 2016 series champion set off after his countryman.
LISTEN TO THE LATEST PODCAST: Mark Skaife l Post-Bathurst Controversy Mkii l Bairdo’s bungle l Triple Eight Turnaround
SUBSCRIBE TO THE SHOW: iTUNES | SPOTIFY | STITCHER
McLaughlin stopped on Lap 50, and Whincup followed him a lap later, the latter retaking effective second.
Trying to build a gap, having found clean air, van Gisbergen was pushing hard and screeched for blue flags at every chance.
On Lap 65, van Gisbergen stopped and emerged with a comfortable gap, and with the RBHRT teammates first and second, the deficit between the leading two teams had been slashed to 77 points.
However, an uncharacteristic error from Whincup at Turn 1 on Lap 75 sent the seven-time champion tumbling to seventh.
Van Gisbergen held a 13-second lead over McLaughlin with five laps remaining, and as the weather closed in on Newcastle, teams readied wet weather tyres in case of a late deluge.
However, despite the dark clouds forming over the city, the weather remained clear as van Gisbergen cruised to his fifth win of the season.
McLaughlin led home teammate Fabian Coulthard to help the Ford squad put one hand on the teams’ gong, with Whincup slumping to eighth.
David Reynolds (#9 Penrite Racing ZB Commodore) and Cameron Waters (#6 Monster Energy Mustang) completed the top five ahead of Scott Pye, who made a brilliant recovery from 24th to sixth following a crash in qualifying.
James Courtney trailed home his Walkinshaw Andretti United teammate to seventh ahead of Whincup, with Tim Slade (#14 Freightliner Racing ZB Commodore) and Mark Winterbottom (#18 IRWIN Racing ZB Commodore) completing the top 10.
With the win, van Gisbergen sealed second in the drivers’ standings.
“Awesome day for us, shame about Jamie making a mistake there, that would’ve been great team points,” he said.
“Thanks to the guys, the car was awesome. I had a cool start, good battle and then forced our way through, so pretty cool.
“Thanks to Shippy [engineer Grant McPherson] for tuning that up in qualifying, that set us up for the win, because you simply just can’t pass here.
“Caught up in the middle stint and then you just get stuck behind. Great strategy to get us the win, that was all a team effort.”
Considering the pace of the factory Holdens, McLaughlin admitted Whincup’s error gifted his team a two-three finish, but was pleased to keep the teams’ championship fight in the Shell team’s corner heading to Sunday.
“It’s tough around here, it’s quite hard work,” McLaughlin said.
“Great job for everyone at Shell V-Power Racing, two and three, obviously Jamie made a mistake there and gifted us a double podium, but I’m sure they’ll come back strong tomorrow.
“Overall, a great team result.”
Full results here.


A practice project from Udacity FullStack Nano Degree.
Shops App(iOS)
Find products carried at nearby stores for over 200,000 store locations. Locate and map products down to the aisle and section inside over 13,000 stores with searchable indoor maps.
Portfolio Project
Build a responsive website using Bootstrap framework. Use customized fonts from Google fonts.


{% if similar_games %}
{% include 'recommendations/recommendation_list.html' with title='Similar' games=similar_games%}
{% endif %}
{% if series %}
{% include 'recommendations/game_list.html' with title='Series' games_list=series|get_items%}
{% endif %}
{% else %}


--- layout: default title: Personal permalink: /personal/ icon: dashboard type: daily ---
现代诗？个人文字汇总


LG_T
Erasure is a complicated subject.
I was born onto a bed of privilege. I’m of white European descent, and my immigrant ancestors came over the ocean long enough ago that my parents could speak the exact same dialect as the teachers at my well-funded suburban public school. They both had graduate degrees, and our home was full of books. I was encouraged towards intellectual pursuits.
My dad ran his own company when I was growing up. We weren’t super rich, but we never went hungry. By virtue of that business, I played with computers from an early age, and learned the basics of strategy and sales as far back as I can remember.
I wasn’t abused or disabled. In fact, for an extremely nerdy kid, I didn’t even get picked on all that much.
On top of that, I’m cismale and straight.
I knew that I was a straight boy, because I liked girls. A lot. Boy, oh, boy, girls were great.
My TV education on human sexuality was clear. There are 5 sharply defined categories.  Straight men go with women, and gay men don’t. So obviously, I was straight.
And just as obvious as my straightness, I knew that some of our culture’s beliefs about straight people were off base. Straight men are also attracted to men. As a straight guy, any argument to the contrary was obviously wrong, because I knew from my own experience. I’d had full-on crushes on male friends of mine, which was clearly a normal thing for normal straight people to do, as evidenced by me, a normal straight person doing it.
  But I feared the teasing, so I didn’t point out their error.
I always felt like it would be an easy thing to “switch teams”, and be gay if I wanted to. The fascination with the “born this way” meme in queer activism never made sense to me. Of course we have a choice in the gender we pursue, doesn’t everyone? Isn’t choice great?
 That would mean I’d have to give up dating women, which I enjoyed.
Heterosexuality carries the privilege of not having to explain why I’m inviting someone out on a date. You’re a woman, I’m a man, we just follow the script that society has handed us.
It’s easy to remain only partly visible.
It took an embarrassingly long time to stop erasing, and become ok with calling myself “bisexual”, even in my own mind.
The realization didn’t come in High School when my crush on another boy had me following him around like a weird giddy puppy. Or in college, when I first kissed a boy. Or the second or third time that boy and I made out.
The scales started to lift from my eyes when I had a conversation with a good friend about the movie “Troy”, well into my 20’s.
He said, “That movie was kind of boring.”
I was shocked, and then I realized he was talking about the plot.
“Well… I didn’t really pay attention to the plot, tbh. That movie’s just lots of Brad Pitt being gorgeous and half-naked.”
“You’re not as straight as you think you are.”
“Yeah, like you’re not attracted to guys sometimes.”
“Nope.”
“Not ever?”
“Not ever.”
“Not even Brad Pitt?”
“Not even a little. You’re bi, dude.”
“Huh.”
 But a lot of things did start to make sense.
My life since then has been significantly more interesting.
I tried on the label like a new pair of shoes, awkward, and uncertain.
Like a good nerd, I dove into the research, but found it surprisingly lacking. Bi Men Coming Out Every Which Way was a great read. I learned about how pervasive the erasure of male bisexuality is, even among academic studies of LGBT culture. It’s as if the B isn’t there.
But how can it be a closet if you go into it and out of it repeatedly, with lovers and families on both sides? That’s not a closet, it’s a room with a revolving door.
The idea that bisexuality might exist is news worthy of the New York Times, even.
Privilege is hard to give up. I can’t overstate how easy it is being straight in public, just letting people think whatever they want. But in the years since I’ve come out to myself, this bugs me more and more.
When meeting a new person, I try to say “partner” rather than “girlfriend”, and sometimes even “they” rather than “she”. The shape of my lover’s body is no business of theirs, after all.
But when I slip, and drop her name, or use female pronouns (which, to be fair, she does use, female as she is), I can’t help but wonder if they’re relieved to find out that I’m not gay, or perhaps just relieved to know which mold I fit into.
I find myself resenting being cast in a mold at all. Even if I say “partner”,
and they assume I’m gay, part of me feels so put upon by that idea. And then here I am making assumptions about what assumptions someone else might be making. It’s a vicious cycle, and there is no escape from the hypocrisy.
I’ve tried since then not to make assumptions about others’ sexual preferences. Yet despite my best intentions, I consistently find myself mentally putting people in the “straight” or “gay” buckets once I find out the gender of their significant other.
The habit of bi erasure is silent and pervasive.
The first time I kissed a boy was almost a dare. In a dorm room, sitting around drinking, as you do. The two girls, roommates, said to the 5 of us boys that they’d both wondered what it would be like to kiss a girl.
You can imagine the reaction.
YES, LADIES, YOU HAVE OUR ATTENTION, PLEASE PROCEED
Afterwards, one of them remarked, “See, that’s why women are better.
He and I both replied, “Bullshit,” and before I knew it, sparks were flying. The other 3 boys in the room were shocked, making the socially required homophobic anguish sounds. I barely remember them being there. I’d been looking all day for an excuse to touch him. It ended too fast, but endures in my mind to this day.
 I don’t know why it should’ve been a surprise. Back then, making out just seemed like a thing straight friends did with each other once in a while.
Again and again, I catch myself being surprised like that. I try to remember that, in fact, a significant portion of men are bisexual, perhaps even a majority, depending on how we decide to define things. I try to yank my thinking out of the mold, but it frequently slips back.
You don’t notice erasure until you stop doing it.
And then you don’t notice when you start again.
I’ve been told by people in the LGBT community that “bisexual isn’t a real thing”, that I’m “actually straight” because I’m with a woman, or even, “men aren’t bisexual, just closeted.” Bi-curious is code for “about to leave the closet”.
 I respond by explaining that they’re just going through a phase. Once they meet the right person not of their stated preferred gender, they’ll grow out of it and realize that they’re actually bi.
But I know, that old “everyone’s bi” story is just another way to push us into the background. If we’re not nonexistent, we’re unremarkable. Either way, nothing to see here. Move along.
    We can’t be trusted, after all. We’re tourists. Unicorns. We don’t exist.
LG_T
Maybe the strangest part about growing up a closeted bisexual is that I’ve been practicing dating girls since puberty. I’m very good at it. Confident. Respectful. Sensitive. Witty. Hungry and giving. It’s not talent or PUA bullshit, and there isn’t any one weird trick. It’s the result of many years of conscientious practice, with loving patient teachers who were learning from me as well; the occasional broken heart that didn’t kill me, even when I felt like it was trying to.
But my experience with men is still so elementary. Men and women are different! Turns. Out. I am 13 all over again, confused and stumbling, sending the wrong signals, and reading every situation backwards. And they are grown men with adult expectations who very reasonably want a peer, not an apprentice. So that’s been tricky.
I don’t have it nearly so rough as the newly-out “baby gays”, celibate well into adulthood.  My heart goes out to them.
At first, I was very careful about who I told. I didn’t want to draw scandal or trolling to my online communities. I didn’t want the drama. I still fear the schoolyard teasing.
Mostly, I didn’t want anyone else telling me how to feel about something I was only beginning to accept myself.
Eventually, I’ve come to see my queerness less as a “thing” to be disclosed, and more as just another part of my private life. Something that friends probably know, and strangers probably don’t, no more scandalous or secret than my address or my allergy to shellfish.
 Straight boys in love today might explore that feeling, without suffering an identity crisis. I wish those lines would blur faster. I wish it was a big deal because love is awesome, instead of being a big deal because of the genders and stated identities of the actors.
My home is technology. This is My Culture, rotten though it can be at times. As a privileged and visible person in it, I feel obligated to try to make it a little better in the ways I can. That’s why I’ve decided to publicly tell this story, so that my presence can add weight to the claim that bisexual men exist.
Maybe this can also be a reminder of the multitude of other things we casually erase from the people around us. There are so many ways we make our friends invisible, unwittingly nudging them into a corner that denies important parts of their identities, by perpetuating memes we don’t even notice.
Erasure isn’t healthy. And we are all unaware that we do it.
Re: Maven is like my girlfriend
First of all: wow, misogyny. As Rick Scott put it, this slide amounts to “Bitches. Amirite?”
A few people have rushed to Doklovic’s defense, claiming, “Nono, you misunderstand; he wasn’t talking about girlfriends as such. Of course that would be inappropriate! No, he was complaining about his specific girlfriend.”
I spent too many years with a partner who used public humiliation, guilt, and intimidation to get their way. They complained in public, in my presence, to our mutual friends that I didn’t make enough money, while spending it all buying those friends drinks.  Then in private, when I told them those things really hurt, they’d tell me that it was just a joke, and I shouldn’t take things so seriously. That my sensitivity is the reason why they have anxiety problems and can’t regulate their emotions without drugs and alcohol.
My self-esteem hit rock bottom. I was empty for years. My family didn’t recognize me. I lost most of my friends, and a valuable chunk of my twenties.
Thankfully, I bounced back.
All totaled, the divorce ended up costing over $80,000, and I consider it the best money I’ve ever spent. Thank the universe there weren’t any kids or mortgages involved.
I’m not sharing this for sympathy. I’ve lived very well since my divorce, and I’m lucky in more ways that anyone has a right to. I had the real power the whole time, and just had to recognize it.
I’m sharing this so that you understand why, when someone shares a slide like this, proudly making a joke at the expense of their significant other, I am struck by blinding rage. If this was about me, I would have dumped him via a public tweet. If I’d been in the audience, there’s a good chance I would have ended up being kicked out of the event.
Saying “Nono, this was about his specific girlfriend, what’s the big deal?” is really no defense. If his girlfriend is a real person, she has real feelings, and I sincerely hope that she has the strength to recognize the problems with this behavior and get out as soon as possible.


i am the header 1 MY IKIGAI
My awesome Web page
Hello there, awesome person! Gyalmo here ! =)
This
Is an
My favorite site is
GitHub
!
This
Is an
UOrdered list


Here at Mike's Pizza of Sonora, we strive to provide the highest quality pizza to our customers.
Year after year we have been awarded the Union Democrat's Best Pizza of the Year Award,
as well as the Lodestar Best Restaurant Award
Customer service is key in our business and we always strive to please our valued customers.
We provide pick-up, dine-in, and party reservation services as well as delivery.
Stop on by and we promise you wont be dissapointed!


array ssh2_sftp_lstat ( resource $sftp , string $path )
Stats a symbolic link on the remote filesystem without following the link. This function is similar to using the lstat() function with the ssh2.sftp:// wrapper in PHP 5 and returns the same values.
See the documentation for stat() for details on the values which may be returned.


| I l@ve RuBoard |
Python is an Open Source tool, and on many platforms, the standard way to install Python is to download the Python sources and run an automated procedure for compiling Python on the machine, resulting in Python binaries that are installed and ready to use. The key advantage of this process is that it can be customized for a particular installation; if you have a specific requirement, it can normally be accommodated.
Under Microsoft Windows, however, this strategy doesn't work. Most people don't have C compilers, and probably would not be happy with the arrangements even if they did. Therefore, Python provides an installation package that contains a version of Python built with useful default options. The installation allows you to choose which components are installed from the following:
The Python core implemented in a Windows DLL named Python1x.dll (e.g., Python15.dll for the Python 1.5 family). This DLL is installed into your PC's Windows system directory.
The standard Python executable, Python.exe . This provides the default interactive prompt and allows you to run Python programs. Additionally, Pythonw.exe is also installed, which allows you to write GUI applications using Python. Only advanced users should employ Pythonw.exe, because Python errors aren't printed; this means that Pythonw.exe usually appears to do nothing, and this is intentional. You should avoid using Pythonw.exe until you are proficient with Python itself.
A few useful Python extension modules providing an interface to such things as .zip compatible compression, the Tkinter GUI library, and so forth. Python extension modules are implemented as Windows DLLs, but are typically provided as .pyd files. For example, the interface to the zlib compression tool is a DLL named zlib.pyd.
The Python library as Python source files (.py). The Python library contains many useful cross-platform modules for working with Python. These include the basic Python library (such as the string and os modules), as well as advanced modules, such as web servers or modules for inspecting and decoding various audio format files.
The Python test suite. This is a set of Python source files that test the Python installation. In general, you don't need to run these tests: they are designed primarily to test ports of Python to new architectures, or by the creators of Python to test major changes to Python itself. If you really feel a need to run this, you can start the Python interpreter and execute the command:
>>> import test.autotest
Python responds with:
test_grammar test_opcodes test_operations test_builtin test_exceptions test_types test_al test test_al skipped -- an optional feature could not be imported ...
A hundred or so lines will print over the next few minutes; it takes some time to complete. Note the last message printed; you will see many of these warnings, and they can be safely ignored.
The Python documentation in HTML format, accessible from the Windows Start Menu.
Headers (.h files) and libraries (.lib files) for the C components needed to build your own extension modules. This is covered in Chapter 22.
The portable GUI environment Tkinter and a Python IDE known as IDLE. Tkinter is discussed in more detail in Chapter 20, while IDLE is discussed in Chapter 4.
Various Python scripts and utility programs. Browse the \tools subdirectory of your Python installation.
You should browse the supplied Python documentation. You will find a reference guide for most of the standard library, as well as the language tutorial and reference. Additionally, you should check for later documentation at http://www.python.org/doc/; it's quite common for new documentation to be written between major Python releases, and the latest documentation is always available for online browsing or download in both HTML and printable (PostScript/PDF) formats.
When Python is installed, a number of configuration options are stored in the Windows registry. The Windows registry provides a central location where programs can store their preferences and settings and provides more features than traditional techniques of saving configuration information.  Whatever your views, good Windows applications, and therefore Python, store their information in the Windows registry.
In general, it isn't necessary for you to understand or edit the registry; Python and any extensions you install normally manages this for you. Indeed, if you are unfamiliar with the Windows registry, you should avoid it completely: it's all too easy to do serious damage to your PC's configuration. However, if you are experienced with the Windows registry or are curious to see how everything works, read on.
The most important configuration option stored in the registry is the PythonPath, the list of directories where Python looks to find modules, which can be viewed at runtime via sys.path . Under Unix, the common way of storing this option is by setting a PYTHONPATH environment variable. Under Windows, this information is stored in the registry rather than in the environment.[1]
[1] It should be noted that Python on Windows can also use the PYTHONPATH environment variable, but by default the value is stored in the registry.
Python also stores other configuration data in the registry, including the location where Python was installed, a list of Python help files, and so forth. For full details on Python's use of the registry, please see the Python documentation.
Let's take a quick look at the Python registry information using the standard Windows Registry Editor. Start the Registry Editor by executing the program regedit.exe (or possibly regedt32.exe on Windows 95, depending on the configuration). You should see a window that looks similar to the Windows Explorer: a list of folders on the left, and data on the right.
Locate the folder named HKEY_LOCAL_MACHINE, and expand it. Locate the sub-folder named Software, and expand it, then continue down through the Python, PythonCore, 1.5, and PythonPath subfolders. Your screen should look something like Figure 3.1, which shows the default PythonPath (i.e., the path used by the Python core) has been installed in E:\Program Files\Python, and the three existing path subkeys: PythonWin, win32, and win32com. These entries have been added by the Python for Windows extensions and contain the additional PythonPath entries required by the respective packages.
If you need to add your own PythonPath entry, you can create a subkey under the PythonPath key and add your new path entries to the key. The names of the keys are for documentation purposes only; they are the name of the package that requires the path entry. Only the key values are actually used by Python itself.
If you open the Windows Explorer after installing Python, you might notice that all .py and .pyc files have their own cute Python icon! If you right-click on a .py file, notice the default menu entry is Run; you can select this entry from the menu or double-click on the .py file to run the program using the standard Python.exe. It's possible that other Python extensions will install new items in this menu; for example, PythonWin (discussed later in this chapter) adds an Edit item, allowing you to open the Python source file for editing.
In addition, you can drag these .py files to your favorite text editor (including PythonWin) for editing. This can be any editor of your choice, or even the standard Windows notepad tool.[2]
[2] Many standard Python library files are supplied with Unix-style line terminators. notepad is still one of the few Windows editors unable to cope with files of this format. For this and other reasons, you shouldn't use notepad to edit Python source.
Running Python programs from the Windows Explorer has one major problem: a new window is created for the Python program, and when it terminates, the window closes immediately. This means that any messages displayed by the program (either informational or error messages) usually vanish just as you are trying to read them. For this reason, most Windows users don't execute their Python programs in this manner; they do so either from the Windows command prompt or from a Python integrated development environment (IDE), such as PythonWin or IDLE.
Both the Windows 95/98 and NT/2000 families come with a command prompt allowing users to run programs from a command-line interface. The Windows command prompt has a long and not-so-glorious history; it has grown from the first versions of MS-DOS and still uses the same basic syntax.
For these discussions, let's assume you have a file named C:\Scripts\hello.py, and this file consists of the single line:
print "Hello from Python"
A first attempt to run this program may surprise you:
C:\Scripts>python.exe hello.py The name specified is not recognized as an internal or external command, operable program or batch file. C:\Scripts>
Although Python.exe has been installed, it hasn't modified the system environment variable PATH: Windows doesn't know how to find Python.exe. Windows NT does, however, know how to run .py files directly. Thus, if you ask the command prompt to execute hello.py, it will:
C:\Scripts>hello.py Hello from Python C:\Scripts>
Take this one step further and avoid the use of the .py extension, making a Python program appear like a .exe, .com, or .bat file. Windows NT supports this using the PATHEXT environment variable. You can view the current settings of this variable by entering the command:
C:\Scripts>echo %PATHEXT% .exe;.bat;.cmd C:\Scripts>
This is a list of the default extensions Windows searches for when a command is executed. You can add Python files to this list (and check the change was successful) by executing:
C:\Scripts>set PATHEXT=%PATHEXT%;.py C:\Scripts>echo %PATHEXT% .exe;.bat;.cmd;.py C:\Scripts>
Now execute your Python programs by specifying the base name of the file:
C:\Scripts>hello Hello from Python C:\Scripts>
For more information, please see the Windows NT documentation.
Unfortunately, none of this applies to Windows 95 or 98, only to Windows NT and 2000. Users of Windows 95 or 98 often take one of the following actions:
Add the Python directory to the system environment variable PATH by modifying their autoexec.bat file.
Copy Python.exe to the Windows system directory. The biggest problems with this are that it's one more file in an already overused directory, and when Python is upgraded, this file may cause some conflicts.
The facilities we described that are available under Windows NT usually make these changes unnecessary.
Finally, both operating systems support using the start command to start Python in a separate window. For example, you could use the command start python.exe to start an interactive Python.exe in a new window or the command start hello.py to run your script in a new window. However, just as with Windows Explorer, this window closes as the program exits, meaning you don't get a chance to read the message printed by your script.
All versions of Windows have some capability for command-line editing: that is, recalling previous commands that have been entered, so they can be reexecuted without retyping them.
Windows NT supports command-line editing by default, but Windows 95 and 98 require you to execute a program named doskey before this functionality is available. Windows 95 and 98 users often configure their environment so that doskey is automatically executed whenever a command prompt is started.
To operate the command-line editing tools, use the arrow keys on the keyboard. The up and down arrows scroll between the commands you executed recently, while the left and right arrow keys allow you to edit the current command. In addition, Windows NT also provides command-line editing for Python.exe ; once you start Python, you can recall previous commands in the same way you can at the command prompt. Unfortunately, Windows 95 or 98 doesn't offer this feature.
The doskey program can also provide command macros. A command macro is a shortcut you assign to a program, so when the shortcut is executed the command prompt, the program is executed.
You can use this to your advantage when working with Python. For example, Windows 95 users who can't take advantage of the Windows NT command prompt can use the following command to assign the shortcut p to execute Python:
C:\Scripts> doskey p="C:\Program Files\Python\Python.exe" $*
The $* at the end of the command indicates that any command-line parameters should be passed to the program, in this case, Python. Thus, you could execute:
C:\Scripts>p hello.py Hello from Python C:\Scripts>
Users of Windows NT and Windows 95 may also like to use these shortcuts to execute their favorite editor. For example, if you execute the following commands:
C:\Scripts>doskey n=start notepad.exe $* C:\Scripts>doskey pw=start pythonwin.exe $*
you could use:
C:\Scripts>n hello.py
to edit the file using notepad, or:
C:\Scripts>pw hello.py
to edit the file using PythonWin.
To take advantage of these doskey macros, you can place them all in a single batch file that can be configured to be run whenever a command prompt is opened. There are many techniques, but a simple one is to place all the commands in a batch file, then modify the shortcut you use to execute the command prompt to include the parameter /k your_batchfile.bat. This forces the command prompt to execute your batch file, but remains open, allowing you to continue entering commands.
Although fairly minor, there are a couple of other features that can help you work with Python.
The first is Copy and Paste. Both Windows 95 and NT support an option that allows you to copy text from the command prompt using the mouse. Windows NT also allows you to paste information into your command prompt with a simple right-click of the mouse. This can be handy when you need to paste a string or sample code into your Python prompt. You can enable this by selecting the Quick Edit option from the command prompt's properties.
Another nice feature for all versions is that you can drag a file from Windows Explorer and drop it into a command prompt, pasting the full filename to the prompt. This can be a handy way to execute Python programs from Windows Explorer without losing the output when the program completes: simply drop the filename onto an existing command prompt and press Enter.
As we have stressed a number of times, Python is cross-platform. Although the sheer market penetration of Windows makes it one of Python's most popular platforms, it's still only one of the many operating systems Python has to work with.
Accordingly, there are some features available on other platforms that don't exist on Windows. To make matters worse, there are a number of features that do work on both platforms, but not in exactly the same way.
Most people who use Python only on Windows never need to worry about these features; they have probably never heard of these functions anyway, and they won't find further comment on them in this book. But for people moving to Windows from the Unix and Linux worlds, seemingly trivial things can cause much aggravation. Although far from exhaustive, some of the more common gotchas are detailed here.
Since the early days of computing (well before Unix), lines in text files were terminated with carriage-return and line-feed characters. This is directly attributable to the early teletype devices that required a command to move the printhead (or carriage) back to the left, and another to eject a new line. The creators of Unix decided the convention was pointless and terminated all lines in text files by the line-feed character, which by then had become known as the newline character. Then the C language came up with a new technique for opening files, such that regardless of the local line-ending conventions, your program would always see a consistent single newline character at the end of each line. A differentiation was made between binary- and text-mode files, which was specified when opening the file.
Unfortunately, over time many Unix programmers became somewhat lazy. As Unix uses a single newline character to terminate lines anyway, there was no difference on that operating system between text- and binary-mode files; the program always worked identically on Unix, regardless of the mode used to open the file. Over time, it became common practice for programmers to omit the binary- or text-mode specifiers completely. To add to the confusion, we also have the Apple Macintosh, which uses a single carriage return.
Windows traces its roots right back to the old teletype days. Every version of Windows, including the most recent, has had to retain some level of compatibility with early versions of MS-DOS, and MS-DOS itself strove to retain some compatibility with CP/M. As a direct result of this history, the common default-line terminator on Windows is a carriage-return character followed by a newline character. This is the file format editors such as notepad use. Most modern editors (including most you are likely to use with Python) support either line convention.
The end result of all this discussion comes down to two points:
If you open a file and wish to see a single newline character terminating each line (regardless of what really terminates the lines), the file should be opened in text mode. You should open in text mode on all operating systems, including Unix where it will have no effect; you never know when some poor soul will try to run your code on a different operating system!
If you open a file and need to see the raw, binary data, you should specify binary mode.
If you open a file in text mode, but it contains binary data, the data often appears corrupt due to the newline and carriage-return mapping. If you open a file in binary mode but you process it as if it contained text data, each line may have additional (or missing) carriage returns at the end of each line.
To open a file in binary mode, append a b to the mode in the open() call. The default is text mode, but on Windows, you can also specify this by appending a t. Thus, to open a file for reading in text mode, use this:
file = open(filename, "r")
Or to open a file for writing in binary mode, use this:
file = open(filename, "wb")
Unix provides a function called fork() to spawn subprocesses. fork() is often used in situations where Windows programmers would consider using threads. Until recently, some of the more popular Unix systems didn't have support for threads, and those that did frequently had their own proprietary API, making it difficult to write portable, threaded code for Unix. fork() has a number of subtleties and features that make it particularly useful in this context, and thus fork() is widespread in the Unix world.
Windows doesn't support fork() and, unfortunately, doesn't support anything that comes close. If you have a Unix program that uses fork(), then porting it to run under Windows is likely to be significant work and requires fairly intimate understanding of the program.
In many cases, the best solution is to rebuild this part of the application for Windows. On a typical Unix machine, creating new processes (as fork() does) is a relatively cheap operation. On Windows, however, the overhead of creating a new process is significant, so solutions using this architecture on Windows won't often scale or perform as you would hope. Rewriting this portion of the application to use multiple threads instead of multiple processes is often the best solution for Windows.
Python exposes the fork() function in the os module (i.e., os.fork() ) on platforms that support it. As Windows isn't one of these supporting platforms, using os.fork() yields an AttributeError exception.
Another common Unixism that causes problems on Windows is the use of the select() function. Under Unix, the select() function determines when more input is available from a file. When your program is reading a file on a disk, you won't have much use for this function. However, it's common for programs to be reading from files that are not on disk: for example, reading the output of another process (i.e., a pipe) or reading data from a network connection. By being notified when a particular file has more data available to read, using select() allows a program to read from multiple files concurrently.
Windows does provide the select() function, but it can be used only with sockets (see Chapter 19). Attempting to use select() with a regular Python file object will fail.
The most common technique on Windows for simple asynchronous input/output is to use threads; and indeed threads are the only portable technique to perform this style of I/O in Python. A simple thread-based solution doesn't scale well once the number of threads becomes large, so Windows provides other native techniques for performing asynchronous I/O.
This issue is similar to the one outlined previously for os.fork(): a feature for working with subprocesses that doesn't work as you may hope on Windows.
Quite often, Unix programs use a function called os.popen() to create a child process and establish a pipe between your process and the new child. Depending on the direction of the pipe, you can read the output from the process or supply input to the process. The most common use of os.popen() is to execute a program and capture its output. When you read from the pipe, you are actually reading the output of the child process.
Although provided under Windows, the os.popen() function is practically useless. Due to various bugs in Windows, os.popen() works only on Windows NT from a console (i.e., DOS prompt) program. Windows 95, 98, and Windows NT GUI programs all fail when attempting to use os.popen().
Bill Tutt has come to the rescue with his various popen() replacement functions for Windows. These functions are exposed in the win32pipe module and documented in the standard Win32 Extensions Help file.
| I l@ve RuBoard |


Heat the olive oil in a large casserole over a medium heat. Season the lamb shoulder, to taste, with salt and freshly ground black pepper.
Add the seasoned lamb shoulder to the casserole and cook, turning regularly, until browned all over. Remove the lamb from the casserole and set aside.
Add the whole onions to the casserole the lamb was cooked in and fry on all sides for 4-5 minutes, or until golden-brown.
Add the garlic and three of the rosemary sprigs and stir well, then return the browned lamb to the casserole and pour over the red wine and stock.
Spread 25g/1oz of the butter over the parts of the lamb not covered by liquid, then place the remaining rosemary sprig on top.
Transfer the casserole to the oven and cook, uncovered, for two hours, or until the lamb is tender and the top is crisp.
Remove the lamb and onions from the cooking juices and set aside (keep warm). Strain the cooking juices into a saucepan and heat over a low to medium heat.
Mix together the flour and remaining butter until well combined, then whisk it into the strained pan juices. Continue to whisk until the mixture forms a thick gravy.
Meanwhile, tear the meat into large pieces using a fork. Place the lamb pieces into the bottom of a medium casserole. Add the cooked onions and pour over the gravy.
Meanwhile, for the topping, preheat the grill to its highest setting. Boil the potatoes in a pan of salted water for 12-15 minutes, or until tender. Drain well, then return the potatoes to the pan. Place the pan over the heat for a few seconds to drive off any excess moisture. Remove the pan from the heat and mash the potatoes until smooth.
Warm the milk over a low heat in a separate pan, then add the milk and the butter to the mashed potatoes and mash again until smooth. Season, to taste, with salt and freshly ground black pepper.
Spoon the mashed potatoes into a piping bag. Pipe the mashed potatoes over the meat filling in the casserole.
Place the casserole under the hot grill and grill until golden-brown.
Meanwhile, for the Vichy carrots, heat the butter, sugar and water in a small pan over a medium heat. When the butter has melted, add the carrots and cover the pan with a lid. Cook for 6-8 minutes, or until tender.
Meanwhile, cook the purple sprouting broccoli in a pan of boiling, salted water for 3-4 minutes, or until tender, then drain well.
To serve, spoon a portion of the pot-roasted shepherd's pie into the centre of each of four serving plates. Spoon the Vichy carrots and purple sprouting broccoli alongside.


Energy Shield
Creates a shield of energy that will nullify incoming damage from elemental attacks.
^a${value} Second(s) Recharge
60
${value} Energy Cost
60 64 68 72 76 80 84 88 92 96 100 104 108 112 116 120
${value} Second Duration
100
${value}% Damage Absorption
10 15 20 25 30 35 40 45 50 55 60 65 70 75 80 85
MaxLevel
12
UltimateLevel
16


 The most beautiful hand will be awarded!!!
Rules: 1.Number of members per teams - 2. One person will paint on his friend’s hand.
2.Event duration - 1 n half Hour Theme - Vintage(Old School)
Judging criteria:
|
Story and Screenplay |
30 |
|
Cinematography |
30 |
|
Editing (also includes background score, sound design, foley, VFX, etc) |
15 |
|
Acting |
10 |
|
Overall Impact (production value, overall vibes from the film, etc) |
15 |
Entry Fee: Rs.50 per team + All
Event Coordinators: Versha:<PHONE_NUMBER>


[Sale of Certificates of Approval]
Currently, you have %DawnTicketLeft% Certificates of Approval remaining.
The Certificate of Approval is issued %DawnTicketBundle% at a time, and each certificate costs %DawnTicketPrice% Adena.
Do you wish to buy a Certificate of Approval?


{% extends "app.html" %} {% block content %}
State This value was returned from the API and should match what was originally sent.
{{state}}
Code This value was sent to the API to be exchanged for an access token.
{{code}}
The eBay API returned the HTTP status code:{{statusCode}}
{% if statusCode == 200 %}Access Token
{{accessToken}}
Token Type
{{tokenType}}
Expires In
{{expiresIn}}
Refresh Token
{{refreshToken}}
Use the above refresh token to generate a new token
{% else %}eBay returned the following error: {{error}} : {{errorDescription}}
{% endif %} {% endblock %}