void sC() {
    dash();
    dot();
    dash();
    dot();
    cBreak();
}

void sJ() {
    dot();
    dash();
    dash();
    dash();
    cBreak();
}

void sP() {
    dot();
    dash();
    dash();
    dot();
    cBreak();
}

void o(void)
{
    dash();
    dash();
    dash();
    delay_ms(LETTERSPACE);
}

void O()
{
	dash();
	beep(200,100);
	space(1);
	dash();
	beep(200,100);
	space(1);
	dash();
	beep(200,100);
	space(3);
}

void Morse::emitWord(String word) {
  int len = word.length();
  int i, ci;
  for (i = 0; i < len; i++) {

    String code = textToMorse(word.charAt(i));
    int codeLen = code.length();
    for (ci = 0; ci < codeLen; ci++) {

      if (code[ci] == '.') {
        dot();
      } else {
        dash();
      }
    }

    // morse code states there should be a 3 time unit pause between
    // characters
    // 2 here and one at the end of dot/dash
    delay(_timeUnit * 2);
  }
  // morse code states there should be a 7 time unit pause between words
  // 4 here and 3 above
  delay(_timeUnit * 4);
}

std::vector< std::vector<double> > readIn2dData(const char* filename)
{
    std::vector< std::vector<double> > table; 
    std::fstream ifs;
    ifs.open(filename);

    while (true)
    {
        std::string line;
	std::string dash ("--");
        double buf;

        getline(ifs, line);	
        std::stringstream ss(line, std::ios_base::out|std::ios_base::in|std::ios_base::binary);

        if (!ifs)
            break;
        if (line[0] == '#' || line.empty() || line == "--" )
            continue;
        std::vector<double> row;
        while (ss >> buf){
            	row.push_back(buf);           
	}
	table.push_back(row);
    }
    ifs.close();
    return table;
}

void TargetPhrase::SetAlignmentInfo(const StringPiece &alignString)
{
	AlignmentInfo::CollType alignTerm, alignNonTerm;
  for (util::TokenIter<util::AnyCharacter, true> token(alignString, util::AnyCharacter(" \t")); token; ++token) {
    util::TokenIter<util::SingleCharacter, false> dash(*token, util::SingleCharacter('-'));

    char *endptr;
    size_t sourcePos = strtoul(dash->data(), &endptr, 10);
    UTIL_THROW_IF(endptr != dash->data() + dash->size(), util::ErrnoException, "Error parsing alignment" << *dash);
    ++dash;
    size_t targetPos = strtoul(dash->data(), &endptr, 10);
    UTIL_THROW_IF(endptr != dash->data() + dash->size(), util::ErrnoException, "Error parsing alignment" << *dash);
    UTIL_THROW_IF(++dash, util::Exception, "Extra gunk in alignment " << *token);


    if (GetWord(targetPos).IsNonTerminal()) {
    	alignNonTerm.insert(std::pair<size_t,size_t>(sourcePos, targetPos));
    }
  	else {
  		alignTerm.insert(std::pair<size_t,size_t>(sourcePos, targetPos));
  	}
  }
  SetAlignTerm(alignTerm);
  SetAlignNonTerm(alignNonTerm);

}

/* proceed one character per cycle */
static inline void loop() {
	byte encodedChar;
	byte charNumSymbols;

	/* read next char */
	char messageChar = message[messageIdx];

	/* handle special cases and validate input */
	if (messageChar == ' ') {  /* space */
		delay(wordSpaceLength_ms - charSpaceLength_ms - blinkSpaceLength_ms);
		advanceChar();
		return;
	} else if (messageChar < '0' ||
		       (messageChar > '9' && messageChar < 'A') ||
		       messageChar > 'Z') {  /* Invalid char! Skip. */
		advanceChar();
		return;
	}

	/* unpack current character encoding */
	encodedChar = morseEncoding[messageChar - '0'];
	charNumSymbols = encodedChar >> 5;  /* top three bits */

	/* iterate over symbols in char frorm right to left */
	while (charNumSymbols--) {
		if (encodedChar & 1) dash();
		else dot();
		delay(blinkSpaceLength_ms);
		encodedChar >>= 1;
	}

	/* terminate char */
	delay(charSpaceLength_ms - blinkSpaceLength_ms);
	advanceChar();
}

// ****************************************************************************
void MolDraw2DSVG::drawLine(const Point2D &cds1, const Point2D &cds2) {
  Point2D c1 = getDrawCoords(cds1);
  Point2D c2 = getDrawCoords(cds2);
  std::string col = DrawColourToSVG(colour());
  unsigned int width = lineWidth();
  std::string dashString = "";
  const DashPattern &dashes = dash();
  if (dashes.size()) {
    std::stringstream dss;
    dss << ";stroke-dasharray:";
    std::copy(dashes.begin(), dashes.end() - 1,
              std::ostream_iterator<unsigned int>(dss, ","));
    dss << dashes.back();
    dashString = dss.str();
  }
  d_os << "<path ";
  if (d_activeClass != "") {
    d_os << "class='" << d_activeClass << "' ";
  }
  d_os << "d='M " << c1.x << "," << c1.y << " " << c2.x << "," << c2.y << "' ";
  d_os << "style='fill:none;fill-rule:evenodd;stroke:" << col
       << ";stroke-width:" << width
       << "px;stroke-linecap:butt;stroke-linejoin:miter;stroke-opacity:1"
       << dashString << "'";
  d_os << " />\n";
}

void sB() {
    dash();
    dot();
    dot();
    dot();
    cBreak();
}

    virtual void onDrawContent(SkCanvas* canvas) {
        SkScalar intervals[8] = { .5f, .3f, .5f, .3f, .5f, .3f, .5f, .3f };
        SkAutoTUnref<SkDashPathEffect> dash(SkDashPathEffect::Create(intervals, 2, fPhase));
        SkAutoTUnref<SkCornerPathEffect> corner(SkCornerPathEffect::Create(.25f));
        SkAutoTUnref<SkComposePathEffect> compose(SkComposePathEffect::Create(dash, corner));

        SkPaint outlinePaint;
        outlinePaint.setAntiAlias(true);  // dashed paint for bitmap
        outlinePaint.setStyle(SkPaint::kStroke_Style);
        outlinePaint.setPathEffect(compose);

        canvas->scale(10.0f, 10.0f);  // scales up

        for (int i = 0; i < fNumBits; ++i) {
            canvas->save();
            for (size_t j = 0; j < SK_ARRAY_COUNT(gBitsToPath_fns); ++j) {
                SkPath path;
                gBitsToPath_fns[j](&path, (char*) &gBits[i], fW, fH, fRowBytes);

                //draw skPath and outline
                canvas->drawPath(path, fBmpPaint);
                canvas->translate(1.5f * fW, 0); // translates past previous bitmap
                canvas->drawPath(path, outlinePaint);
                canvas->translate(1.5f * fW, 0); // translates past previous bitmap
            }
            canvas->restore();
            canvas->translate(0, 1.5f * fH); //translate to next row
        }

        // for animated pathEffect
        fPhase += .01f;
        this->inval(NULL);
    }

int DoTurnKickCommand(TurnKickCommand com)
{
  if (com.time != Mem->CurrentTime) {
    my_error("DoTurnKickCommand- told to do command not set this cycle");
    return 0;
  }
    
  switch (com.type) {
  case CMD_none:
    break;
  case CMD_dash:
    DebugKick(printf("DoTurnKickCommand: dash\n"));
    dash(com.power);
    break;
  case CMD_turn:
    DebugKick(printf("DoTurnKickCommand: turn\n"));
    turn(com.angle);
    break;
  case CMD_kick:
    DebugKick(printf("DoTurnKickCommand: kick\n"));
    kick(com.power, com.angle);
    break;

  default:
    my_error("DoTurnKickCommand- unimplemented type!");
    return 0;
  }

  if (com.turn_neck) {
    turn_neck(com.turn_neck_angle);
  }
  return 1;  
}

    virtual void onDrawContent(SkCanvas* canvas) {
        static const char* gStr[] = {
            "11",
            "44",
            "112233",
            "411327463524",
        };

        SkPaint paint;
        paint.setStrokeWidth(SkIntToScalar(1));

        SkScalar x0 = SkIntToScalar(10);
        SkScalar y0 = SkIntToScalar(10);
        SkScalar x1 = x0 + SkIntToScalar(1000);
        for (size_t i = 0; i < SK_ARRAY_COUNT(gStr); i++) {
            SkScalar interval[12];
            size_t len = SkMin32(strlen(gStr[i]), SK_ARRAY_COUNT(interval));
            for (size_t j = 0; j < len; j++) {
                interval[j] = SkIntToScalar(gStr[i][j] - '0');
            }

            SkDashPathEffect dash(interval, len, 0);
            paint.setPathEffect(&dash);
            canvas->drawLine(x0, y0, x1, y0, paint);
            paint.setPathEffect(NULL);

            y0 += paint.getStrokeWidth() * 3;
        }

        setBitmapDash(&paint, 3);
        canvas->drawLine(x0, y0, x1, y0, paint);
    }

int main(int argc, char ** argv) {
    char * string = argv[1];
    char * morse_string;
    int current_char;

    wiringPiSetup () ;
    pinMode (OUTPUT_PIN, OUTPUT) ;

    puts(string);
    while(*string) {
        current_char = (*string | 32) - 'a';

        if (current_char >= 0 && current_char < 26) {
            morse_string = conversion_map[current_char];
            while(*morse_string) {
                if (*morse_string == '.') {
                    dot();
                } else if (*morse_string == '-') {
                    dash();
                }

                morse_string++;
            }
        }
        delay(CHAR_DELAY);
        string++;
    }
    return 0;
}

    static void validateTopicName(const QString& topic)
    {
        if (topic.isEmpty())
        {
            throw std::invalid_argument("empty topic");
        }

        // Can't start or end with a '/' but anywhere else is okay
        // Can't have "//" as that implies empty token
        if (topic.startsWith("/") || topic.endsWith("/") ||
                topic.contains("//"))
        {
            throw std::invalid_argument(QString("invalid topic: %1").arg(topic).toStdString());
        }

        QString::const_iterator topicEnd = topic.end();
        QChar A('A'), Z('Z'), a('a'), z('z'), zero('0'), nine('9');
        QChar dash('-'), slash('/'), underscore('_');
        for (QString::const_iterator i = topic.begin(); i < topicEnd; ++i)
        {
            QChar c(*i);
            if ((A <= c) && (c <= Z)) continue;
            if ((a <= c) && (c <= z)) continue;
            if ((zero <= c) && (c <= nine)) continue;
            if ((c == underscore) || (c == dash) || (c == slash)) continue;
            throw std::invalid_argument(QString("invalid topic: %1").arg(topic).toStdString());
        }
    }

DEF_TEST(DashPathEffectTest_crbug_348821, r) {
    SkScalar intervals[] = { 1.76934361e+36f, 2.80259693e-45f };  // Values from bug.
    const int count = 2;
    SkScalar phase = SK_ScalarInfinity;  // Used to force a nonsense effect.
    sk_sp<SkPathEffect> dash(SkDashPathEffect::Make(intervals, count, phase));

    REPORTER_ASSERT(r, dash == nullptr);
}

// Test out the asPoint culling behavior.
DEF_TEST(DashPathEffectTest_asPoints, r) {

    const SkScalar intervals[] = { 1.0f, 1.0f };
    const int count = 2;
    SkAutoTUnref<SkDashPathEffect> dash(SkDashPathEffect::Create(intervals, count, 0.0f));

    SkRect cull = SkRect::MakeWH(1.0f, 1.0f);

    const struct {
        SkPoint fPts[2];
        bool    fExpectedResult;
    } testCases[] = {
        { { { -5.0f,  0.5f }, { -4.0f,  0.5f } }, false },   // off to the left
        { { {  4.0f,  0.5f }, {  5.0f,  0.5f } }, false },   // off to the right
        { { {  0.5f,  4.0f }, {  0.5f,  5.0f } }, false },   // off the bottom
        { { {  0.5f, -5.0f }, {  0.5f, -4.0f } }, false },   // off the top
        { { {  0.5f,  0.2f }, {  0.5f,  0.8f } }, true  },   // entirely inside vertical
        { { {  0.2f,  0.5f }, {  0.8f,  0.5f } }, true  },   // entirely inside horizontal
        { { {  0.5f, -5.0f }, {  0.5f,  5.0f } }, true  },   // straddles both sides vertically
        { { { -5.0f,  0.5f }, {  5.0f,  0.5f } }, true  },   // straddles both sides horizontally
        { { {  0.5f, -5.0f }, {  0.5f,  0.5f } }, true  },   // straddles top
        { { {  0.5f,  5.0f }, {  0.5f,  0.5f } }, true  },   // straddles bottom
        { { { -5.0f,  0.5f }, {  0.5f,  0.5f } }, true  },   // straddles left
        { { {  5.0f,  0.5f }, {  0.5f,  0.5f } }, true  },   // straddles right
        { { {  0.5f,  0.5f }, {  0.5f,  0.5f } }, false },   // zero length
    };

    SkPaint paint;
    paint.setStyle(SkPaint::kStroke_Style);
    paint.setStrokeWidth(1.0f);
    SkStrokeRec rec(paint);

    static const int kNumMats = 3;
    SkMatrix mats[kNumMats];
    mats[0].reset();
    mats[1].setRotate(90, 0.5f, 0.5f);
    mats[2].setTranslate(10.0f, 10.0f);

    for (int i = 0; i < kNumMats; ++i) {
        for (int j = 0; j < (int)SK_ARRAY_COUNT(testCases); ++j) {
            for (int k = 0; k < 2; ++k) {  // exercise alternating endpoints
                SkPathEffect::PointData results;
                SkPath src;

                src.moveTo(testCases[j].fPts[k]);
                src.lineTo(testCases[j].fPts[(k+1)%2]);

                bool actualResult = dash->asPoints(&results, src, rec, mats[i], &cull);
                if (i < 2) {
                    REPORTER_ASSERT(r, actualResult == testCases[j].fExpectedResult);
                } else {
                    // On the third pass all the lines should be outside the translated cull rect
                    REPORTER_ASSERT(r, !actualResult);
                }
            }
        }
    }
}

static void test_crbug_124652() {
    /*
        http://code.google.com/p/chromium/issues/detail?id=124652
        This particular test/bug only applies to the float case, where
        large values can "swamp" small ones.
     */
    SkScalar intervals[2] = {837099584, 33450};
    SkAutoTUnref<SkDashPathEffect> dash(SkDashPathEffect::Create(intervals, 2, -10));
}

/* LITERE */
void A()
{
	dot();
	beep(100,25);
	space(1);
	dash();
	beep(200,100);
	space(3);
}