package main

import (
	"bufio"
	"fmt"
	"io"
	"log"
	"math"
	"os"
	"strconv"
	"strings"
)

const maxCapacity = 512 * 1024

var (
	sc = bufio.NewScanner(os.Stdin)
	wr = bufio.NewWriter(os.Stdout)
)

func main() {
	buf := make([]byte, maxCapacity)
	sc.Split(bufio.ScanWords)
	sc.Buffer(buf, maxCapacity)
	defer wr.Flush()

	inarr := readIntArray(2)
	n, m := inarr[0], inarr[1]
	res := 0
	for i := n; i <= m; i++ {
		if (n+m+i)%3 == 0 {
			res++
		}
	}

	fmt.Fprintln(wr, res)
}

func readScInt() int {
	sc.Scan()
	return atoi(sc.Text())
}

func readScIntArr(n int) []int {
	var arr []int
	for i := 0; i < n; i++ {
		arr = append(arr, readScInt())
	}
	return arr
}

func readScStr() string {
	sc.Scan()
	return sc.Text()
}

func readStdinLines(n int) []string {
	var lines []string
	for i := 0; i < n; i++ {
		sc.Scan()
		lines = append(lines, sc.Text())
	}
	return lines
}

func readIntArray(n int) []int {
	arr := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Scanf("%d", &arr[i])
	}
	return arr
}

func readMatrix(x, y int) [][]int {
	mtx := make([][]int, x)
	for i := range mtx {
		mtx[i] = make([]int, y)
	}
	for i := 0; i < x; i++ {
		for ii := 0; ii < y; ii++ {
			fmt.Scanf("%d", &mtx[i][ii])
		}
	}
	return mtx
}

func readMatrixFromLines(lines []string) [][]int {
	m := make([][]int, len(lines))
	for i, v := range lines {
		s := strings.Split(v, " ")
		for _, vv := range s {
			m[i] = append(m[i], atoi(vv))
		}
	}
	return m
}

func fpf(w io.Writer, format string, a ...any) {
	_, err := fmt.Fprintf(w, format, a...)
	if err != nil {
		log.Fatalln(err)
	}
}

func fpl(w io.Writer, a ...any) {
	_, err := fmt.Fprintln(w, a...)
	if err != nil {
		log.Fatalln(err)
	}
}

func plf(v ...interface{}) {
	fmt.Println(v...)
}

func pll(v ...interface{}) {
	log.Println(v...)
}

func groupSting(str string) []string {
	var res []string
	var tmp string
	for i, v := range str {
		s := string(v)
		if i < len(str)-1 && s == string(str[i+1]) {
			tmp += s
		} else {
			res = append(res, tmp+s)
			tmp = ""
		}
	}
	return res
}

func splitString(s string) []string {
	return strings.Split(s, "")
}

func reverseString(s string) string {
	rns := []rune(s)
	for i, j := 0, len(rns)-1; i < j; i, j = i+1, j-1 {
		rns[i], rns[j] = rns[j], rns[i]
	}
	return string(rns)
}

func atoi(s string) int {
	int, err := strconv.Atoi(s)
	if err != nil {
		log.Fatalln(err)
	}
	return int
}

func absInt(a, b int) int {
	abs := math.Abs(float64(a - b))
	return int(abs)
}

func ceilInt(f float64) int {
	res := int(math.Ceil(f))
	return res
}

func floorInt(f float64) int {
	res := int(math.Floor(f))
	return res
}

func minMaxInt(a, b int) (min, max int) {
	if a >= b {
		return b, a
	}
	return a, b
}

func powInt(n, m int) int {
	if m == 0 {
		return 1
	}
	res := n
	for i := 2; i <= m; i++ {
		res *= n
	}
	return res
}

func powUint64(x, n uint64) uint64 {
	if n == 0 {
		return 1
	} else if n == 1 {
		return x
	}
	y := powUint64(x, n/2)
	if n%2 == 0 {
		return y * y
	}
	return x * y * y
}

func binsearch(arr []int, target int) int {
	low, high := 0, len(arr)-1

	for low <= high {
		mid := low + (high-low)/2
		if arr[mid] == target {
			return mid
		}
		if arr[mid] < target {
			low = mid + 1
		} else {
			high = mid - 1
		}
	}
	return -1
}

func gcd(a, b int) int {
	for b != 0 {
		a, b = b, a%b
	}
	return a
}