// Left causes the drone to bank to the left, controls the roll, which is
// a horizontal movement using the camera as a reference point.
// speed can be a value from `0` to `100`.
328276
func (a *Driver) Left(speed int) {
	a.adaptor().drone.Left(speed)
}
72596
func Ne(left, right interface{}) Condition {
	return Condition{
		Type:  ConditionNe,
		Left:  NewOperand(left),
		Right: NewOperand(right),
	}
}
437632
func (s *StepperDriver) Move(stepsToMove int) error {
	if stepsToMove == 0 {
		return s.Halt()
	}

	if s.moving == true {
		//stop previous motion
		s.Halt()
	}

	s.mutex.Lock()
	s.moving = true
	s.direction = "forward"

	if stepsToMove < 0 {
		s.direction = "backward"
	}
	s.mutex.Unlock()

	stepsLeft := int64(math.Abs(float64(stepsToMove)))
	//Do not remove *1000 and change duration to time.Millisecond. It has been done for a reason
	delay := time.Duration(60000*1000/(s.stepsPerRev*s.speed)) * time.Microsecond

	for stepsLeft > 0 {
		if err := s.step(); err != nil {
			return err
		}
		stepsLeft--
		time.Sleep(delay)
	}

	s.moving = false
	return nil
}
466897
func (b *LEDDriver) DownRightArrow() (err error) {
	buf := []byte{0x10, 0x09, 0x05, 0x03, 0x0F}
	err = b.WriteMatrix(buf)
	return
}
10836
func (l *Line) Direction() float64 {
	return math.Atan2(l.b[1]-l.a[1], l.b[0]-l.a[0])
}
189094
func (b *Driver) Right(val int) error {
	b.pcmdMutex.Lock()
	defer b.pcmdMutex.Unlock()

	b.Pcmd.Flag = 1
	b.Pcmd.Roll = validatePitch(val)
	return nil
}
1030337
func lessThan(key string) func(left, right interface{}) bool {
	return func(left, right interface{}) bool {
		val := reflect.Indirect(reflect.ValueOf(left))
		rval := reflect.Indirect(reflect.ValueOf(right))
		switch val.Kind() {
		case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
			return val.Int() < rval.Int()
		case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint, reflect.Uint64:
			return val.Uint() < rval.Uint()
		case reflect.Float32, reflect.Float64:
			return val.Float() < rval.Float()
		case reflect.String:
			return val.String() < rval.String()
		case reflect.MapOf(
			reflect.TypeOf(reflect.String),
			reflect.TypeOf(reflect.Interface),
		).Kind():
			kval := reflect.ValueOf(key)
			if !val.MapIndex(kval).IsValid() {
				return false
			}
			newleft := val.MapIndex(kval).Interface()
			newright := rval.MapIndex(kval).Interface()
			return lessThan("")(newleft, newright)
		case reflect.Struct:
			if !val.FieldByName(key).IsValid() {
				return false
			}
			newleft := val.FieldByName(key).Interface()
			newright := rval.FieldByName(key).Interface()
			return lessThan("")(newleft, newright)
		default:
			// it's not really comparable, so...
			return false
		}
	}
}
1081113
func (ms *MatStack) LeftMul(m mgl32.Mat4) {
	(*ms)[len(*ms)-1] = m.Mul4((*ms)[len(*ms)-1])
}
947556
func (buf *Buffer) Left() error {
	if buf.pos <= 0 {
		return nil
	}

	buf.pos--
	return buf.Refresh()
}
1192943
func (a *Writer) Left(n int) (int, error) {
	return a.WriteString(Left(n))
}
1328929
func (d *Driver) Right(val int) error {
	d.cmdMutex.Lock()
	defer d.cmdMutex.Unlock()

	d.rx = float32(val) / 100.0
	return nil
}
953351
func Rotate(p, axis Point, angle s1.Angle) Point {
	// Let M be the plane through P that is perpendicular to axis, and let
	// center be the point where M intersects axis. We construct a
	// right-handed orthogonal frame (dx, dy, center) such that dx is the
	// vector from center to P, and dy has the same length as dx. The
	// result can then be expressed as (cos(angle)*dx + sin(angle)*dy + center).
	center := axis.Mul(p.Dot(axis.Vector))
	dx := p.Sub(center)
	dy := axis.Cross(p.Vector)
	// Mathematically the result is unit length, but normalization is necessary
	// to ensure that numerical errors don't accumulate.
	return Point{dx.Mul(math.Cos(angle.Radians())).Add(dy.Mul(math.Sin(angle.Radians()))).Add(center).Normalize()}
}
160608
func (this *token_iterator) skip_to_left_curly() bool {
	return this.skip_to_left(token.LBRACE, token.RBRACE)
}
743175
func (b *Driver) RightFlip() (err error) {
	return b.adaptor().WriteCharacteristic(commandCharacteristic, b.generateAnimation(2).Bytes())
}
2377
func (qb *TiDBQueryBuilder) LeftJoin(table string) QueryBuilder {
	qb.Tokens = append(qb.Tokens, "LEFT JOIN", table)
	return qb
}
1229908
func leftPad(input []byte, size int) (out []byte) {
	n := len(input)
	if n > size {
		n = size
	}
	out = make([]byte, size)
	copy(out[len(out)-n:], input)
	return
}
438514
func (a *Driver) Clockwise(speed int) {
	a.adaptor().drone.Clockwise(speed)
}