// 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.0` to `1.0`.
334548
func (a *Driver) Left(speed float64) {
	a.adaptor().drone.Left(speed)
}
255779
func (a *Driver) Right(speed int) {
	a.adaptor().drone.Right(speed)
}
55608
func (ms *MatStack) LeftMul(m mgl64.Mat4) {
	(*ms)[len(*ms)-1] = m.Mul4((*ms)[len(*ms)-1])
}
641852
func (l *Line) Side(p *Point) int {
	val := (l.b[0]-l.a[0])*(p[1]-l.b[1]) - (l.b[1]-l.a[1])*(p[0]-l.b[0])

	if val < 0 {
		return 1 // right
	} else if val > 0 {
		return -1 // left
	}

	return 0 // collinear
}
40938
func (d *RabinKarp64) Roll(c byte) {
	// This check costs 10-15% performance. If we disable it, we crash
	// when the window is empty. If we enable it, we are always correct
	// (an empty window never changes no matter how much you roll it).
	//if len(d.window) == 0 {
	//	return
	//}
	// extract the entering/leaving bytes and update the circular buffer.
	enter := c
	leave := uint64(d.window[d.oldest])
	d.window[d.oldest] = c
	d.oldest += 1
	if d.oldest >= len(d.window) {
		d.oldest = 0
	}

	d.value ^= d.tables.out[leave]
	index := byte(d.value >> d.polShift)
	d.value <<= 8
	d.value |= Pol(enter)
	d.value ^= d.tables.mod[index]
}
931580
func (a *Driver) CounterClockwise(speed float64) {
	a.adaptor().drone.Counterclockwise(speed)
}
959927
func (a *Driver) Right(speed float64) {
	a.adaptor().drone.Right(speed)
}
941437
func DirectionLtr() Property {
	property := Property{propertyType: "direction"}
	property.values = append(property.values, "ltr")

	return property
}
1192224
func SetsAreEqual(left, right ValueList) bool {
	if left.ValueType() != right.ValueType() {
		return false
	}
	if left.Size() != right.Size() {
		return false
	}

	if isHashable(left.ValueType()) {
		return setsArEqualHashable(left.Size(), left, right)
	}
	return setsAreEqualUnhashable(left.Size(), left, right)
}
532596
func (a *Driver) CounterClockwise(speed int) {
	a.adaptor().drone.CounterClockwise(speed)
}
873629
func (c *MouseRotator) Update(float32) {
	if engo.Input.Mouse.Button == engo.MouseButtonMiddle && engo.Input.Mouse.Action == engo.Press {
		c.pressed = true
	}

	if engo.Input.Mouse.Action == engo.Release {
		c.pressed = false
	}

	if c.pressed {
		engo.Mailbox.Dispatch(CameraMessage{Axis: Angle, Value: (c.oldX - engo.Input.Mouse.X) * -c.RotationSpeed, Incremental: true})
	}

	c.oldX = engo.Input.Mouse.X
}
389871
func LeftPadZero(input string, padLength int) string {
	return fmt.Sprintf(`%0*s`, padLength, input)
}
841025
func (m Matrix) Moved(delta Vec) Matrix {
	m[4], m[5] = m[4]+delta.X, m[5]+delta.Y
	return m
}
1116603
func IsRightWinding(a, b *T) bool {
	ab := b.Rotated(-a.Angle())
	return ab.Angle() < 0
}
1329663
func (w *Window) JoystickAxis(js Joystick, axis int) float64 {
	return w.currJoy.getAxis(js, axis)
}
1156055
func ValuesAreEqual(left, right Value) bool {
	if left.typ != right.typ {
		return false
	}

	switch left.typ {
	case TBool:
		return left.GetBool() == right.GetBool()
	case TI8:
		return left.GetI8() == right.GetI8()
	case TDouble:
		return left.GetDouble() == right.GetDouble()
	case TI16:
		return left.GetI16() == right.GetI16()
	case TI32:
		return left.GetI32() == right.GetI32()
	case TI64:
		return left.GetI64() == right.GetI64()
	case TBinary:
		return bytes.Equal(left.tbinary, right.tbinary)
	case TStruct:
		return StructsAreEqual(left.tstruct, right.tstruct)
	case TMap:
		return MapsAreEqual(left.tcoll.(MapItemList), right.tcoll.(MapItemList))
	case TSet:
		return SetsAreEqual(left.tcoll.(ValueList), right.tcoll.(ValueList))
	case TList:
		return ListsAreEqual(left.tcoll.(ValueList), right.tcoll.(ValueList))
	default:
		return false
	}
}
1280960
func (me *Dataset) LeftJoin(table Expression, condition joinExpression) *Dataset {
	return me.joinTable(LEFT_JOIN, table, condition)
}