Merge lp:~mzanetti/reminders-app/integrate-plugin into lp:reminders-app

[Michael Zanetti]

add evernote-sdk, libthrift and a qml plugin

This adds:

* evernote-sdk-cpp
* libthrift (required by evernote-sdk-cpp)
* a Evernote QML plugin

Additionally it moves the existing QML files around a bit to fit better with the 3rdParty + Plugin directories.

Given the fact that we need to compile C++ now, the qmlproject file is not of much use any more, so I've dropped it, but created a ready to go .pro file for you. We can change this later to cmake if that's wanted. But for now this .pro file should get us going.

You should be able to open "reminders-app.pro" in QtCreator and just click on build. You might need to install libboost-dev if you haven't yet. The libraries are linked statically and there is a minimalistic self-made qmlscene which loads the plugin path automatically. So nothing special to do. Just open and click on "play". Note that the main.cpp is not really required as we can still run everything in qmlscene, but I've added it for convenience as with qmlscene we'd need to add the -I and plugin path. We do not need to ship this in the final package if you prefer using qmlscene for whatever reason.

I've also updated the existing UI code a little bit to make use of the stuff that's available in the plugin to show you how to use it. Along with that I dropped the components dir as the fake model in there is now replaced by real functionality (well, I'll add support for reminders soon, so far only Notes and Notebooks).

What this does NOT:
* There is no write access yet. All we can do so far is reading stuff.

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:8
http://91.189.93.70:8080/job/reminders-app-ci/2/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/199/console
    FAILURE: http://91.189.93.70:8080/job/reminders-app-raring-amd64-ci/2/console
    FAILURE: http://91.189.93.70:8080/job/reminders-app-saucy-amd64-ci/2/console
    FAILURE: http://91.189.93.70:8080/job/reminders-app-trusty-amd64-ci/2/console

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/reminders-app-ci/2/rebuild

review: Needs Fixing (continuous-integration)

[David Planella (dpm)]

Note for reviewers: in addition to libboost-dev, you'll need to install libssl-dev too to test the code.

[David Planella (dpm)]

Excellent work, I could get it to fetch and render my notes. There are only a couple of minor things I noticed:

1) There is a typo in the reminders-app.qml file:

file:///tmp/build-reminders-app-Desktop-Debug/src/app/qml/reminders-app.qml:61:23: Reminders is not a type
                     page: Reminders {
                           ^
That needs to be RemindersPage

2) This is simply a suggestion, but could we use something more generic to name the 3rdParty folder and project file? That is, could we use 'lib' instead of '3rdParty'?

review: Needs Fixing

[lp:~mzanetti/reminders-app/integrate-plugin]

9. By Michael Zanetti on 2013-11-22

fix reminders page renaming

[Michael Zanetti (mzanetti)]

> 1) There is a typo in the reminders-app.qml file:

fixed.

> 2) This is simply a suggestion, but could we use something more generic to
> name the 3rdParty folder and project file? That is, could we use 'lib' instead
> of '3rdParty'?

Usually "lib" is used for libs that are part of this source code, i.e. if we would write it our own. 3rdParty indicates that this is really just imported without major modifications. So in my opinion keeping it to 3rdParty would be better. But if you guys agree this should be renamed to "lib" I can sure do that.

[lp:~mzanetti/reminders-app/integrate-plugin]

10. By Michael Zanetti on 2013-11-22

drop unneeded reference to example code

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:9
http://91.189.93.70:8080/job/reminders-app-ci/3/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/200/console
    FAILURE: http://91.189.93.70:8080/job/reminders-app-raring-amd64-ci/3/console
    FAILURE: http://91.189.93.70:8080/job/reminders-app-saucy-amd64-ci/3/console
    FAILURE: http://91.189.93.70:8080/job/reminders-app-trusty-amd64-ci/3/console

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/reminders-app-ci/3/rebuild

review: Needs Fixing (continuous-integration)

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:10
http://91.189.93.70:8080/job/reminders-app-ci/4/
Executed test runs:
    FAILURE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/201/console
    FAILURE: http://91.189.93.70:8080/job/reminders-app-raring-amd64-ci/4/console
    FAILURE: http://91.189.93.70:8080/job/reminders-app-saucy-amd64-ci/4/console
    FAILURE: http://91.189.93.70:8080/job/reminders-app-trusty-amd64-ci/4/console

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/reminders-app-ci/4/rebuild

review: Needs Fixing (continuous-integration)

[lp:~mzanetti/reminders-app/integrate-plugin]

11. By Michael Zanetti on 2013-11-22

fix packaging

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:11
http://91.189.93.70:8080/job/reminders-app-ci/5/
Executed test runs:
    UNSTABLE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/205
    FAILURE: http://91.189.93.70:8080/job/reminders-app-raring-amd64-ci/5/console
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-saucy-amd64-ci/5
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-trusty-amd64-ci/5

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/reminders-app-ci/5/rebuild

review: Needs Fixing (continuous-integration)

[lp:~mzanetti/reminders-app/integrate-plugin]

12. By Michael Zanetti on 2013-11-22

"fix" autopilot tests

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:12
http://91.189.93.70:8080/job/reminders-app-ci/6/
Executed test runs:
    UNSTABLE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/206
    FAILURE: http://91.189.93.70:8080/job/reminders-app-raring-amd64-ci/6/console
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-saucy-amd64-ci/6
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-trusty-amd64-ci/6

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/reminders-app-ci/6/rebuild

review: Needs Fixing (continuous-integration)

[lp:~mzanetti/reminders-app/integrate-plugin]

13. By Michael Zanetti on 2013-11-22

add fake check target to make jenkins happy

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

FAILED: Continuous integration, rev:13
http://91.189.93.70:8080/job/reminders-app-ci/7/
Executed test runs:
    UNSTABLE: http://91.189.93.70:8080/job/generic-mediumtests-trusty/207
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-raring-amd64-ci/7
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-saucy-amd64-ci/7
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-trusty-amd64-ci/7

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/reminders-app-ci/7/rebuild

review: Needs Fixing (continuous-integration)

[lp:~mzanetti/reminders-app/integrate-plugin]

14. By Michael Zanetti on 2013-11-22

more fixes for autopilot

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

PASSED: Continuous integration, rev:14
http://91.189.93.70:8080/job/reminders-app-ci/8/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/208
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-raring-amd64-ci/8
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-saucy-amd64-ci/8
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-trusty-amd64-ci/8

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/reminders-app-ci/8/rebuild

review: Approve (continuous-integration)

[lp:~mzanetti/reminders-app/integrate-plugin]

15. By Michael Zanetti on 2013-11-22

fix target name

16. By Michael Zanetti on 2013-11-22

fix architecture for packages

[Ubuntu Phone Apps Jenkins Bot (ubuntu-phone-apps-jenkins-bot)]

PASSED: Continuous integration, rev:16
http://91.189.93.70:8080/job/reminders-app-ci/9/
Executed test runs:
    SUCCESS: http://91.189.93.70:8080/job/generic-mediumtests-trusty/210
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-raring-amd64-ci/9
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-saucy-amd64-ci/9
    SUCCESS: http://91.189.93.70:8080/job/reminders-app-trusty-amd64-ci/9

Click here to trigger a rebuild:
http://91.189.93.70:8080/job/reminders-app-ci/9/rebuild

review: Approve (continuous-integration)

[David Planella (dpm)]

Not sure why Jenkins has not picked this up or whether it is a problem with my setup, but trying to build the package fails with the following errors:

E: reminders-app source: not-binnmuable-all-depends-any reminders-app-autopilot -> reminders-app
E: reminders-app: missing-dependency-on-libc needed by usr/lib/x86_64-linux-gnu/qt5/qml/Evernote/libevernoteplugin.so

[lp:~mzanetti/reminders-app/integrate-plugin]

17. By Michael Zanetti on 2013-11-22

add run_on_ubuntu_touch.sh script and fix .desktop file for click packaging

[Michael Zanetti (mzanetti)]

> Not sure why Jenkins has not picked this up or whether it is a problem with my
> setup, but trying to build the package fails with the following errors:
>
> E: reminders-app source: not-binnmuable-all-depends-any reminders-app-
> autopilot -> reminders-app
> E: reminders-app: missing-dependency-on-libc needed by usr/lib/x86_64-linux-
> gnu/qt5/qml/Evernote/libevernoteplugin.so

Hmm... I don't see this here and tbh I've no clue what is wrong. How do you build the package?

[lp:~mzanetti/reminders-app/integrate-plugin]

18. By Michael Zanetti on 2013-11-22

fix apparmor policy to allow accessing accounts

[David Planella (dpm)]

I'm building the package on 13.10 from the root of the source tree with:

debuild -us -uc

On Sat, Nov 23, 2013 at 12:12 AM, Michael Zanetti <
<email address hidden>> wrote:

> > Not sure why Jenkins has not picked this up or whether it is a problem
> with my
> > setup, but trying to build the package fails with the following errors:
> >
> > E: reminders-app source: not-binnmuable-all-depends-any reminders-app-
> > autopilot -> reminders-app
> > E: reminders-app: missing-dependency-on-libc needed by
> usr/lib/x86_64-linux-
> > gnu/qt5/qml/Evernote/libevernoteplugin.so
>
> Hmm... I don't see this here and tbh I've no clue what is wrong. How do
> you build the package?
> --
>
> https://code.launchpad.net/~mzanetti/reminders-app/integrate-plugin/+merge/196210
> You are reviewing the proposed merge of
> lp:~mzanetti/reminders-app/integrate-plugin into lp:reminders-app.
>

[David Planella (dpm)]

It seems that the packages build regardless of the error, and since Jenkins is happy with it and the branch works as expected, I'll just go ahead and approve it.

One thing I've noticed while using the app is that it sometimes seems to lose the connection with Evernote, and it stops fetching Notes or Notebooks (this can be easily seen in the Qt Creator console with the error messages).

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2013-10-23 11:02:37 +0000
+++ .bzrignore	2013-11-22 21:43:19 +0000
@@ -1,1 +1,2 @@
 reminders-app.qmlproject.user
+reminders-app.pro.user

=== added directory '3rdParty'
=== added file '3rdParty/3rdParty.pro'
--- 3rdParty/3rdParty.pro	1970-01-01 00:00:00 +0000
+++ 3rdParty/3rdParty.pro	2013-11-22 21:43:19 +0000
@@ -0,0 +1,4 @@
+TEMPLATE = subdirs
+SUBDIRS = libthrift evernote-sdk-cpp
+
+evernote-sdk-cpp.depends = libthrift

=== added directory '3rdParty/evernote-sdk-cpp'
=== added directory '3rdParty/evernote-sdk-cpp/.git'
=== added file '3rdParty/evernote-sdk-cpp/.git/HEAD'
--- 3rdParty/evernote-sdk-cpp/.git/HEAD	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/HEAD	2013-11-22 21:43:19 +0000
@@ -0,0 +1,1 @@
+ref: refs/heads/master

=== added directory '3rdParty/evernote-sdk-cpp/.git/branches'
=== added file '3rdParty/evernote-sdk-cpp/.git/config'
--- 3rdParty/evernote-sdk-cpp/.git/config	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/config	2013-11-22 21:43:19 +0000
@@ -0,0 +1,11 @@
+[core]
+	repositoryformatversion = 0
+	filemode = true
+	bare = false
+	logallrefupdates = true
+[remote "origin"]
+	url = https://github.com/evernote/evernote-sdk-cpp.git
+	fetch = +refs/heads/*:refs/remotes/origin/*
+[branch "master"]
+	remote = origin
+	merge = refs/heads/master

=== added file '3rdParty/evernote-sdk-cpp/.git/description'
--- 3rdParty/evernote-sdk-cpp/.git/description	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/description	2013-11-22 21:43:19 +0000
@@ -0,0 +1,1 @@
+Unnamed repository; edit this file 'description' to name the repository.

=== added directory '3rdParty/evernote-sdk-cpp/.git/hooks'
=== added file '3rdParty/evernote-sdk-cpp/.git/hooks/applypatch-msg.sample'
--- 3rdParty/evernote-sdk-cpp/.git/hooks/applypatch-msg.sample	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/hooks/applypatch-msg.sample	2013-11-22 21:43:19 +0000
@@ -0,0 +1,15 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message taken by
+# applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.  The hook is
+# allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "applypatch-msg".
+
+. git-sh-setup
+test -x "$GIT_DIR/hooks/commit-msg" &&
+	exec "$GIT_DIR/hooks/commit-msg" ${1+"$@"}
+:

=== added file '3rdParty/evernote-sdk-cpp/.git/hooks/commit-msg.sample'
--- 3rdParty/evernote-sdk-cpp/.git/hooks/commit-msg.sample	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/hooks/commit-msg.sample	2013-11-22 21:43:19 +0000
@@ -0,0 +1,24 @@
+#!/bin/sh
+#
+# An example hook script to check the commit log message.
+# Called by "git commit" with one argument, the name of the file
+# that has the commit message.  The hook should exit with non-zero
+# status after issuing an appropriate message if it wants to stop the
+# commit.  The hook is allowed to edit the commit message file.
+#
+# To enable this hook, rename this file to "commit-msg".
+
+# Uncomment the below to add a Signed-off-by line to the message.
+# Doing this in a hook is a bad idea in general, but the prepare-commit-msg
+# hook is more suited to it.
+#
+# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"
+
+# This example catches duplicate Signed-off-by lines.
+
+test "" = "$(grep '^Signed-off-by: ' "$1" |
+	 sort | uniq -c | sed -e '/^[ 	]*1[ 	]/d')" || {
+	echo >&2 Duplicate Signed-off-by lines.
+	exit 1
+}

=== added file '3rdParty/evernote-sdk-cpp/.git/hooks/post-update.sample'
--- 3rdParty/evernote-sdk-cpp/.git/hooks/post-update.sample	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/hooks/post-update.sample	2013-11-22 21:43:19 +0000
@@ -0,0 +1,8 @@
+#!/bin/sh
+#
+# An example hook script to prepare a packed repository for use over
+# dumb transports.
+#
+# To enable this hook, rename this file to "post-update".
+
+exec git update-server-info

=== added file '3rdParty/evernote-sdk-cpp/.git/hooks/pre-applypatch.sample'
--- 3rdParty/evernote-sdk-cpp/.git/hooks/pre-applypatch.sample	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/hooks/pre-applypatch.sample	2013-11-22 21:43:19 +0000
@@ -0,0 +1,14 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed
+# by applypatch from an e-mail message.
+#
+# The hook should exit with non-zero status after issuing an
+# appropriate message if it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-applypatch".
+
+. git-sh-setup
+test -x "$GIT_DIR/hooks/pre-commit" &&
+	exec "$GIT_DIR/hooks/pre-commit" ${1+"$@"}
+:

=== added file '3rdParty/evernote-sdk-cpp/.git/hooks/pre-commit.sample'
--- 3rdParty/evernote-sdk-cpp/.git/hooks/pre-commit.sample	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/hooks/pre-commit.sample	2013-11-22 21:43:19 +0000
@@ -0,0 +1,50 @@
+#!/bin/sh
+#
+# An example hook script to verify what is about to be committed.
+# Called by "git commit" with no arguments.  The hook should
+# exit with non-zero status after issuing an appropriate message if
+# it wants to stop the commit.
+#
+# To enable this hook, rename this file to "pre-commit".
+
+if git rev-parse --verify HEAD >/dev/null 2>&1
+then
+	against=HEAD
+else
+	# Initial commit: diff against an empty tree object
+	against=4b825dc642cb6eb9a060e54bf8d69288fbee4904
+fi
+
+# If you want to allow non-ascii filenames set this variable to true.
+allownonascii=$(git config hooks.allownonascii)
+
+# Redirect output to stderr.
+exec 1>&2
+
+# Cross platform projects tend to avoid non-ascii filenames; prevent
+# them from being added to the repository. We exploit the fact that the
+# printable range starts at the space character and ends with tilde.
+if [ "$allownonascii" != "true" ] &&
+	# Note that the use of brackets around a tr range is ok here, (it's
+	# even required, for portability to Solaris 10's /usr/bin/tr), since
+	# the square bracket bytes happen to fall in the designated range.
+	test $(git diff --cached --name-only --diff-filter=A -z $against |
+	  LC_ALL=C tr -d '[ -~]\0' | wc -c) != 0
+then
+	echo "Error: Attempt to add a non-ascii file name."
+	echo
+	echo "This can cause problems if you want to work"
+	echo "with people on other platforms."
+	echo
+	echo "To be portable it is advisable to rename the file ..."
+	echo
+	echo "If you know what you are doing you can disable this"
+	echo "check using:"
+	echo
+	echo "  git config hooks.allownonascii true"
+	echo
+	exit 1
+fi
+
+# If there are whitespace errors, print the offending file names and fail.
+exec git diff-index --check --cached $against --

=== added file '3rdParty/evernote-sdk-cpp/.git/hooks/pre-push.sample'
--- 3rdParty/evernote-sdk-cpp/.git/hooks/pre-push.sample	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/hooks/pre-push.sample	2013-11-22 21:43:19 +0000
@@ -0,0 +1,53 @@
+#!/bin/sh
+
+# An example hook script to verify what is about to be pushed.  Called by "git
+# push" after it has checked the remote status, but before anything has been
+# pushed.  If this script exits with a non-zero status nothing will be pushed.
+#
+# This hook is called with the following parameters:
+#
+# $1 -- Name of the remote to which the push is being done
+# $2 -- URL to which the push is being done
+#
+# If pushing without using a named remote those arguments will be equal.
+#
+# Information about the commits which are being pushed is supplied as lines to
+# the standard input in the form:
+#
+#   <local ref> <local sha1> <remote ref> <remote sha1>
+#
+# This sample shows how to prevent push of commits where the log message starts
+# with "WIP" (work in progress).
+
+remote="$1"
+url="$2"
+
+z40=0000000000000000000000000000000000000000
+
+IFS=' '
+while read local_ref local_sha remote_ref remote_sha
+do
+	if [ "$local_sha" = $z40 ]
+	then
+		# Handle delete
+	else
+		if [ "$remote_sha" = $z40 ]
+		then
+			# New branch, examine all commits
+			range="$local_sha"
+		else
+			# Update to existing branch, examine new commits
+			range="$remote_sha..$local_sha"
+		fi
+
+		# Check for WIP commit
+		commit=`git rev-list -n 1 --grep '^WIP' "$range"`
+		if [ -n "$commit" ]
+		then
+			echo "Found WIP commit in $local_ref, not pushing"
+			exit 1
+		fi
+	fi
+done
+
+exit 0

=== added file '3rdParty/evernote-sdk-cpp/.git/hooks/pre-rebase.sample'
--- 3rdParty/evernote-sdk-cpp/.git/hooks/pre-rebase.sample	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/hooks/pre-rebase.sample	2013-11-22 21:43:19 +0000
@@ -0,0 +1,169 @@
+#!/bin/sh
+#
+# Copyright (c) 2006, 2008 Junio C Hamano
+#
+# The "pre-rebase" hook is run just before "git rebase" starts doing
+# its job, and can prevent the command from running by exiting with
+# non-zero status.
+#
+# The hook is called with the following parameters:
+#
+# $1 -- the upstream the series was forked from.
+# $2 -- the branch being rebased (or empty when rebasing the current branch).
+#
+# This sample shows how to prevent topic branches that are already
+# merged to 'next' branch from getting rebased, because allowing it
+# would result in rebasing already published history.
+
+publish=next
+basebranch="$1"
+if test "$#" = 2
+then
+	topic="refs/heads/$2"
+else
+	topic=`git symbolic-ref HEAD` ||
+	exit 0 ;# we do not interrupt rebasing detached HEAD
+fi
+
+case "$topic" in
+refs/heads/??/*)
+	;;
+*)
+	exit 0 ;# we do not interrupt others.
+	;;
+esac
+
+# Now we are dealing with a topic branch being rebased
+# on top of master.  Is it OK to rebase it?
+
+# Does the topic really exist?
+git show-ref -q "$topic" || {
+	echo >&2 "No such branch $topic"
+	exit 1
+}
+
+# Is topic fully merged to master?
+not_in_master=`git rev-list --pretty=oneline ^master "$topic"`
+if test -z "$not_in_master"
+then
+	echo >&2 "$topic is fully merged to master; better remove it."
+	exit 1 ;# we could allow it, but there is no point.
+fi
+
+# Is topic ever merged to next?  If so you should not be rebasing it.
+only_next_1=`git rev-list ^master "^$topic" ${publish} | sort`
+only_next_2=`git rev-list ^master           ${publish} | sort`
+if test "$only_next_1" = "$only_next_2"
+then
+	not_in_topic=`git rev-list "^$topic" master`
+	if test -z "$not_in_topic"
+	then
+		echo >&2 "$topic is already up-to-date with master"
+		exit 1 ;# we could allow it, but there is no point.
+	else
+		exit 0
+	fi
+else
+	not_in_next=`git rev-list --pretty=oneline ^${publish} "$topic"`
+	/usr/bin/perl -e '
+		my $topic = $ARGV[0];
+		my $msg = "* $topic has commits already merged to public branch:\n";
+		my (%not_in_next) = map {
+			/^([0-9a-f]+) /;
+			($1 => 1);
+		} split(/\n/, $ARGV[1]);
+		for my $elem (map {
+				/^([0-9a-f]+) (.*)$/;
+				[$1 => $2];
+			} split(/\n/, $ARGV[2])) {
+			if (!exists $not_in_next{$elem->[0]}) {
+				if ($msg) {
+					print STDERR $msg;
+					undef $msg;
+				}
+				print STDERR " $elem->[1]\n";
+			}
+		}
+	' "$topic" "$not_in_next" "$not_in_master"
+	exit 1
+fi
+
+<<\DOC_END
+
+This sample hook safeguards topic branches that have been
+published from being rewound.
+
+The workflow assumed here is:
+
+ * Once a topic branch forks from "master", "master" is never
+   merged into it again (either directly or indirectly).
+
+ * Once a topic branch is fully cooked and merged into "master",
+   it is deleted.  If you need to build on top of it to correct
+   earlier mistakes, a new topic branch is created by forking at
+   the tip of the "master".  This is not strictly necessary, but
+   it makes it easier to keep your history simple.
+
+ * Whenever you need to test or publish your changes to topic
+   branches, merge them into "next" branch.
+
+The script, being an example, hardcodes the publish branch name
+to be "next", but it is trivial to make it configurable via
+$GIT_DIR/config mechanism.
+
+With this workflow, you would want to know:
+
+(1) ... if a topic branch has ever been merged to "next".  Young
+    topic branches can have stupid mistakes you would rather
+    clean up before publishing, and things that have not been
+    merged into other branches can be easily rebased without
+    affecting other people.  But once it is published, you would
+    not want to rewind it.
+
+(2) ... if a topic branch has been fully merged to "master".
+    Then you can delete it.  More importantly, you should not
+    build on top of it -- other people may already want to
+    change things related to the topic as patches against your
+    "master", so if you need further changes, it is better to
+    fork the topic (perhaps with the same name) afresh from the
+    tip of "master".
+
+Let's look at this example:
+
+		   o---o---o---o---o---o---o---o---o---o "next"
+		  /       /           /           /
+		 /   a---a---b A     /           /
+		/   /               /           /
+	       /   /   c---c---c---c B         /
+	      /   /   /             \         /
+	     /   /   /   b---b C     \       /
+	    /   /   /   /             \     /
+    ---o---o---o---o---o---o---o---o---o---o---o "master"
+
+
+A, B and C are topic branches.
+
+ * A has one fix since it was merged up to "next".
+
+ * B has finished.  It has been fully merged up to "master" and "next",
+   and is ready to be deleted.
+
+ * C has not merged to "next" at all.
+
+We would want to allow C to be rebased, refuse A, and encourage
+B to be deleted.
+
+To compute (1):
+
+	git rev-list ^master ^topic next
+	git rev-list ^master        next
+
+	if these match, topic has not merged in next at all.
+
+To compute (2):
+
+	git rev-list master..topic
+
+	if this is empty, it is fully merged to "master".
+
+DOC_END

=== added file '3rdParty/evernote-sdk-cpp/.git/hooks/prepare-commit-msg.sample'
--- 3rdParty/evernote-sdk-cpp/.git/hooks/prepare-commit-msg.sample	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/hooks/prepare-commit-msg.sample	2013-11-22 21:43:19 +0000
@@ -0,0 +1,36 @@
+#!/bin/sh
+#
+# An example hook script to prepare the commit log message.
+# Called by "git commit" with the name of the file that has the
+# commit message, followed by the description of the commit
+# message's source.  The hook's purpose is to edit the commit
+# message file.  If the hook fails with a non-zero status,
+# the commit is aborted.
+#
+# To enable this hook, rename this file to "prepare-commit-msg".
+
+# This hook includes three examples.  The first comments out the
+# "Conflicts:" part of a merge commit.
+#
+# The second includes the output of "git diff --name-status -r"
+# into the message, just before the "git status" output.  It is
+# commented because it doesn't cope with --amend or with squashed
+# commits.
+#
+# The third example adds a Signed-off-by line to the message, that can
+# still be edited.  This is rarely a good idea.
+
+case "$2,$3" in
+  merge,)
+    /usr/bin/perl -i.bak -ne 's/^/# /, s/^# #/#/ if /^Conflicts/ .. /#/; print' "$1" ;;
+
+# ,|template,)
+#   /usr/bin/perl -i.bak -pe '
+#      print "\n" . `git diff --cached --name-status -r`
+#	 if /^#/ && $first++ == 0' "$1" ;;
+
+  *) ;;
+esac
+
+# SOB=$(git var GIT_AUTHOR_IDENT | sed -n 's/^\(.*>\).*$/Signed-off-by: \1/p')
+# grep -qs "^$SOB" "$1" || echo "$SOB" >> "$1"

=== added file '3rdParty/evernote-sdk-cpp/.git/hooks/update.sample'
--- 3rdParty/evernote-sdk-cpp/.git/hooks/update.sample	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/hooks/update.sample	2013-11-22 21:43:19 +0000
@@ -0,0 +1,128 @@
+#!/bin/sh
+#
+# An example hook script to blocks unannotated tags from entering.
+# Called by "git receive-pack" with arguments: refname sha1-old sha1-new
+#
+# To enable this hook, rename this file to "update".
+#
+# Config
+# ------
+# hooks.allowunannotated
+#   This boolean sets whether unannotated tags will be allowed into the
+#   repository.  By default they won't be.
+# hooks.allowdeletetag
+#   This boolean sets whether deleting tags will be allowed in the
+#   repository.  By default they won't be.
+# hooks.allowmodifytag
+#   This boolean sets whether a tag may be modified after creation. By default
+#   it won't be.
+# hooks.allowdeletebranch
+#   This boolean sets whether deleting branches will be allowed in the
+#   repository.  By default they won't be.
+# hooks.denycreatebranch
+#   This boolean sets whether remotely creating branches will be denied
+#   in the repository.  By default this is allowed.
+#
+
+# --- Command line
+refname="$1"
+oldrev="$2"
+newrev="$3"
+
+# --- Safety check
+if [ -z "$GIT_DIR" ]; then
+	echo "Don't run this script from the command line." >&2
+	echo " (if you want, you could supply GIT_DIR then run" >&2
+	echo "  $0 <ref> <oldrev> <newrev>)" >&2
+	exit 1
+fi
+
+if [ -z "$refname" -o -z "$oldrev" -o -z "$newrev" ]; then
+	echo "usage: $0 <ref> <oldrev> <newrev>" >&2
+	exit 1
+fi
+
+# --- Config
+allowunannotated=$(git config --bool hooks.allowunannotated)
+allowdeletebranch=$(git config --bool hooks.allowdeletebranch)
+denycreatebranch=$(git config --bool hooks.denycreatebranch)
+allowdeletetag=$(git config --bool hooks.allowdeletetag)
+allowmodifytag=$(git config --bool hooks.allowmodifytag)
+
+# check for no description
+projectdesc=$(sed -e '1q' "$GIT_DIR/description")
+case "$projectdesc" in
+"Unnamed repository"* | "")
+	echo "*** Project description file hasn't been set" >&2
+	exit 1
+	;;
+esac
+
+# --- Check types
+# if $newrev is 0000...0000, it's a commit to delete a ref.
+zero="0000000000000000000000000000000000000000"
+if [ "$newrev" = "$zero" ]; then
+	newrev_type=delete
+else
+	newrev_type=$(git cat-file -t $newrev)
+fi
+
+case "$refname","$newrev_type" in
+	refs/tags/*,commit)
+		# un-annotated tag
+		short_refname=${refname##refs/tags/}
+		if [ "$allowunannotated" != "true" ]; then
+			echo "*** The un-annotated tag, $short_refname, is not allowed in this repository" >&2
+			echo "*** Use 'git tag [ -a | -s ]' for tags you want to propagate." >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,delete)
+		# delete tag
+		if [ "$allowdeletetag" != "true" ]; then
+			echo "*** Deleting a tag is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/tags/*,tag)
+		# annotated tag
+		if [ "$allowmodifytag" != "true" ] && git rev-parse $refname > /dev/null 2>&1
+		then
+			echo "*** Tag '$refname' already exists." >&2
+			echo "*** Modifying a tag is not allowed in this repository." >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,commit)
+		# branch
+		if [ "$oldrev" = "$zero" -a "$denycreatebranch" = "true" ]; then
+			echo "*** Creating a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/heads/*,delete)
+		# delete branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	refs/remotes/*,commit)
+		# tracking branch
+		;;
+	refs/remotes/*,delete)
+		# delete tracking branch
+		if [ "$allowdeletebranch" != "true" ]; then
+			echo "*** Deleting a tracking branch is not allowed in this repository" >&2
+			exit 1
+		fi
+		;;
+	*)
+		# Anything else (is there anything else?)
+		echo "*** Update hook: unknown type of update to ref $refname of type $newrev_type" >&2
+		exit 1
+		;;
+esac
+
+# --- Finished
+exit 0

=== added file '3rdParty/evernote-sdk-cpp/.git/index'
Binary files 3rdParty/evernote-sdk-cpp/.git/index	1970-01-01 00:00:00 +0000 and 3rdParty/evernote-sdk-cpp/.git/index	2013-11-22 21:43:19 +0000 differ
=== added directory '3rdParty/evernote-sdk-cpp/.git/info'
=== added file '3rdParty/evernote-sdk-cpp/.git/info/exclude'
--- 3rdParty/evernote-sdk-cpp/.git/info/exclude	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/info/exclude	2013-11-22 21:43:19 +0000
@@ -0,0 +1,6 @@
+# git ls-files --others --exclude-from=.git/info/exclude
+# Lines that start with '#' are comments.
+# For a project mostly in C, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~

=== added directory '3rdParty/evernote-sdk-cpp/.git/logs'
=== added file '3rdParty/evernote-sdk-cpp/.git/logs/HEAD'
--- 3rdParty/evernote-sdk-cpp/.git/logs/HEAD	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/logs/HEAD	2013-11-22 21:43:19 +0000
@@ -0,0 +1,1 @@
+0000000000000000000000000000000000000000 8ff7baba6c6fb73fe8cc14ef51b321890f09bc40 Michael Zanetti <[e-mail]> 1384442360 +0100	clone: from https://github.com/evernote/evernote-sdk-cpp.git

=== added directory '3rdParty/evernote-sdk-cpp/.git/logs/refs'
=== added directory '3rdParty/evernote-sdk-cpp/.git/logs/refs/heads'
=== added file '3rdParty/evernote-sdk-cpp/.git/logs/refs/heads/master'
--- 3rdParty/evernote-sdk-cpp/.git/logs/refs/heads/master	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/logs/refs/heads/master	2013-11-22 21:43:19 +0000
@@ -0,0 +1,1 @@
+0000000000000000000000000000000000000000 8ff7baba6c6fb73fe8cc14ef51b321890f09bc40 Michael Zanetti <[e-mail]> 1384442360 +0100	clone: from https://github.com/evernote/evernote-sdk-cpp.git

=== added directory '3rdParty/evernote-sdk-cpp/.git/logs/refs/remotes'
=== added directory '3rdParty/evernote-sdk-cpp/.git/logs/refs/remotes/origin'
=== added file '3rdParty/evernote-sdk-cpp/.git/logs/refs/remotes/origin/HEAD'
--- 3rdParty/evernote-sdk-cpp/.git/logs/refs/remotes/origin/HEAD	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/logs/refs/remotes/origin/HEAD	2013-11-22 21:43:19 +0000
@@ -0,0 +1,1 @@
+0000000000000000000000000000000000000000 8ff7baba6c6fb73fe8cc14ef51b321890f09bc40 Michael Zanetti <[e-mail]> 1384442360 +0100	clone: from https://github.com/evernote/evernote-sdk-cpp.git

=== added directory '3rdParty/evernote-sdk-cpp/.git/objects'
=== added directory '3rdParty/evernote-sdk-cpp/.git/objects/e6'
=== added file '3rdParty/evernote-sdk-cpp/.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391'
Binary files 3rdParty/evernote-sdk-cpp/.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391	1970-01-01 00:00:00 +0000 and 3rdParty/evernote-sdk-cpp/.git/objects/e6/9de29bb2d1d6434b8b29ae775ad8c2e48c5391	2013-11-22 21:43:19 +0000 differ
=== added directory '3rdParty/evernote-sdk-cpp/.git/objects/info'
=== added directory '3rdParty/evernote-sdk-cpp/.git/objects/pack'
=== added file '3rdParty/evernote-sdk-cpp/.git/objects/pack/pack-67281df39073784444642b09601e438f46d74a25.idx'
Binary files 3rdParty/evernote-sdk-cpp/.git/objects/pack/pack-67281df39073784444642b09601e438f46d74a25.idx	1970-01-01 00:00:00 +0000 and 3rdParty/evernote-sdk-cpp/.git/objects/pack/pack-67281df39073784444642b09601e438f46d74a25.idx	2013-11-22 21:43:19 +0000 differ
=== added file '3rdParty/evernote-sdk-cpp/.git/objects/pack/pack-67281df39073784444642b09601e438f46d74a25.pack'
Binary files 3rdParty/evernote-sdk-cpp/.git/objects/pack/pack-67281df39073784444642b09601e438f46d74a25.pack	1970-01-01 00:00:00 +0000 and 3rdParty/evernote-sdk-cpp/.git/objects/pack/pack-67281df39073784444642b09601e438f46d74a25.pack	2013-11-22 21:43:19 +0000 differ
=== added file '3rdParty/evernote-sdk-cpp/.git/packed-refs'
--- 3rdParty/evernote-sdk-cpp/.git/packed-refs	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/packed-refs	2013-11-22 21:43:19 +0000
@@ -0,0 +1,3 @@
+# pack-refs with: peeled fully-peeled 
+8ff7baba6c6fb73fe8cc14ef51b321890f09bc40 refs/remotes/origin/dev
+8ff7baba6c6fb73fe8cc14ef51b321890f09bc40 refs/remotes/origin/master

=== added directory '3rdParty/evernote-sdk-cpp/.git/refs'
=== added directory '3rdParty/evernote-sdk-cpp/.git/refs/heads'
=== added file '3rdParty/evernote-sdk-cpp/.git/refs/heads/master'
--- 3rdParty/evernote-sdk-cpp/.git/refs/heads/master	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/refs/heads/master	2013-11-22 21:43:19 +0000
@@ -0,0 +1,1 @@
+8ff7baba6c6fb73fe8cc14ef51b321890f09bc40

=== added directory '3rdParty/evernote-sdk-cpp/.git/refs/remotes'
=== added directory '3rdParty/evernote-sdk-cpp/.git/refs/remotes/origin'
=== added file '3rdParty/evernote-sdk-cpp/.git/refs/remotes/origin/HEAD'
--- 3rdParty/evernote-sdk-cpp/.git/refs/remotes/origin/HEAD	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/.git/refs/remotes/origin/HEAD	2013-11-22 21:43:19 +0000
@@ -0,0 +1,1 @@
+ref: refs/remotes/origin/master

=== added directory '3rdParty/evernote-sdk-cpp/.git/refs/tags'
=== added file '3rdParty/evernote-sdk-cpp/APACHE-LICENSE-2.0.txt'
--- 3rdParty/evernote-sdk-cpp/APACHE-LICENSE-2.0.txt	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/APACHE-LICENSE-2.0.txt	2013-11-22 21:43:19 +0000
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

=== added file '3rdParty/evernote-sdk-cpp/LICENSE'
--- 3rdParty/evernote-sdk-cpp/LICENSE	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/LICENSE	2013-11-22 21:43:19 +0000
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2007-2012 by Evernote Corporation, All rights reserved.
+ *
+ * Use of the source code and binary libraries included in this package
+ * is permitted under the following terms:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.    
+ */

=== added file '3rdParty/evernote-sdk-cpp/NOTICE'
--- 3rdParty/evernote-sdk-cpp/NOTICE	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/NOTICE	2013-11-22 21:43:19 +0000
@@ -0,0 +1,5 @@
+Apache Thrift
+Copyright 2006-2010 The Apache Software Foundation.
+
+This product includes software developed at
+The Apache Software Foundation (http://www.apache.org/).
\ No newline at end of file

=== added file '3rdParty/evernote-sdk-cpp/README.md'
--- 3rdParty/evernote-sdk-cpp/README.md	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/README.md	2013-11-22 21:43:19 +0000
@@ -0,0 +1,14 @@
+Evernote SDK for C++
+=========================================
+
+Evernote API version 1.25
+
+Overview
+--------
+This SDK contains wrapper code used to call the Evernote Cloud API from C++ apps.
+
+Prerequisites
+-------------
+In order to use the code in this SDK, you need to obtain an API key from http://dev.evernote.com/documentation/cloud. You'll also find full API documentation on that page.
+
+In order to run the sample code, you need a user account on the sandbox service where you will do your development. Sign up for an account at https://sandbox.evernote.com/Registration.action 

=== added file '3rdParty/evernote-sdk-cpp/evernote-sdk-cpp.pro'
--- 3rdParty/evernote-sdk-cpp/evernote-sdk-cpp.pro	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/evernote-sdk-cpp.pro	2013-11-22 21:43:19 +0000
@@ -0,0 +1,35 @@
+TEMPLATE = lib
+
+CONFIG = staticlib
+
+QMAKE_CXXFLAGS += -std=c++0x -fPIC
+
+INCLUDEPATH += ../libthrift
+
+LIBS += -L../libthrift -llibthrift
+
+SOURCES +=  src/Errors_constants.cpp \
+    src/Errors_types.cpp \
+    src/Limits_constants.cpp \
+    src/Limits_types.cpp \
+    src/NoteStore_constants.cpp \
+    src/NoteStore.cpp \
+    src/NoteStore_types.cpp \
+    src/Types_constants.cpp \
+    src/Types_types.cpp \
+    src/UserStore_constants.cpp \
+    src/UserStore.cpp \
+    src/UserStore_types.cpp
+
+HEADERS += src/Errors_constants.h \
+    src/Errors_types.h \
+    src/Limits_constants.h \
+    src/Limits_types.h \
+    src/NoteStore_constants.h \
+    src/NoteStore.h \
+    src/NoteStore_types.h \
+    src/Types_constants.h \
+    src/Types_types.h \
+    src/UserStore_constants.h \
+    src/UserStore.h \
+    src/UserStore_types.h

=== added directory '3rdParty/evernote-sdk-cpp/src'
=== added file '3rdParty/evernote-sdk-cpp/src/Errors_constants.cpp'
--- 3rdParty/evernote-sdk-cpp/src/Errors_constants.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/src/Errors_constants.cpp	2013-11-22 21:43:19 +0000
@@ -0,0 +1,16 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#include "Errors_constants.h"
+
+namespace evernote { namespace edam {
+
+const ErrorsConstants g_Errors_constants;
+
+ErrorsConstants::ErrorsConstants() {
+}
+
+}} // namespace
+

=== added file '3rdParty/evernote-sdk-cpp/src/Errors_constants.h'
--- 3rdParty/evernote-sdk-cpp/src/Errors_constants.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/src/Errors_constants.h	2013-11-22 21:43:19 +0000
@@ -0,0 +1,23 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#ifndef Errors_CONSTANTS_H
+#define Errors_CONSTANTS_H
+
+#include "Errors_types.h"
+
+namespace evernote { namespace edam {
+
+class ErrorsConstants {
+ public:
+  ErrorsConstants();
+
+};
+
+extern const ErrorsConstants g_Errors_constants;
+
+}} // namespace
+
+#endif

=== added file '3rdParty/evernote-sdk-cpp/src/Errors_types.cpp'
--- 3rdParty/evernote-sdk-cpp/src/Errors_types.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/src/Errors_types.cpp	2013-11-22 21:43:19 +0000
@@ -0,0 +1,236 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#include "Errors_types.h"
+
+namespace evernote { namespace edam {
+
+const char* EDAMUserException::ascii_fingerprint = "24652790C81ECE22B629CB60A19F1E93";
+const uint8_t EDAMUserException::binary_fingerprint[16] = {0x24,0x65,0x27,0x90,0xC8,0x1E,0xCE,0x22,0xB6,0x29,0xCB,0x60,0xA1,0x9F,0x1E,0x93};
+
+uint32_t EDAMUserException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_errorCode = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast0;
+          xfer += iprot->readI32(ecast0);
+          this->errorCode = (EDAMErrorCode::type)ecast0;
+          isset_errorCode = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->parameter);
+          this->__isset.parameter = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_errorCode)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t EDAMUserException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("EDAMUserException");
+  xfer += oprot->writeFieldBegin("errorCode", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->errorCode);
+  xfer += oprot->writeFieldEnd();
+  if (this->__isset.parameter) {
+    xfer += oprot->writeFieldBegin("parameter", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeString(this->parameter);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+const char* EDAMSystemException::ascii_fingerprint = "106D9EB644563D065C091D0BD32D7D44";
+const uint8_t EDAMSystemException::binary_fingerprint[16] = {0x10,0x6D,0x9E,0xB6,0x44,0x56,0x3D,0x06,0x5C,0x09,0x1D,0x0B,0xD3,0x2D,0x7D,0x44};
+
+uint32_t EDAMSystemException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+  bool isset_errorCode = false;
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          int32_t ecast1;
+          xfer += iprot->readI32(ecast1);
+          this->errorCode = (EDAMErrorCode::type)ecast1;
+          isset_errorCode = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->message);
+          this->__isset.message = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->rateLimitDuration);
+          this->__isset.rateLimitDuration = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_errorCode)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t EDAMSystemException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("EDAMSystemException");
+  xfer += oprot->writeFieldBegin("errorCode", ::apache::thrift::protocol::T_I32, 1);
+  xfer += oprot->writeI32((int32_t)this->errorCode);
+  xfer += oprot->writeFieldEnd();
+  if (this->__isset.message) {
+    xfer += oprot->writeFieldBegin("message", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeString(this->message);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.rateLimitDuration) {
+    xfer += oprot->writeFieldBegin("rateLimitDuration", ::apache::thrift::protocol::T_I32, 3);
+    xfer += oprot->writeI32(this->rateLimitDuration);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+const char* EDAMNotFoundException::ascii_fingerprint = "D0297FC5011701BD87898CC36146A565";
+const uint8_t EDAMNotFoundException::binary_fingerprint[16] = {0xD0,0x29,0x7F,0xC5,0x01,0x17,0x01,0xBD,0x87,0x89,0x8C,0xC3,0x61,0x46,0xA5,0x65};
+
+uint32_t EDAMNotFoundException::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->identifier);
+          this->__isset.identifier = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->key);
+          this->__isset.key = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t EDAMNotFoundException::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("EDAMNotFoundException");
+  if (this->__isset.identifier) {
+    xfer += oprot->writeFieldBegin("identifier", ::apache::thrift::protocol::T_STRING, 1);
+    xfer += oprot->writeString(this->identifier);
+    xfer += oprot->writeFieldEnd();
+  }
+  if (this->__isset.key) {
+    xfer += oprot->writeFieldBegin("key", ::apache::thrift::protocol::T_STRING, 2);
+    xfer += oprot->writeString(this->key);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+}} // namespace

=== added file '3rdParty/evernote-sdk-cpp/src/Errors_types.h'
--- 3rdParty/evernote-sdk-cpp/src/Errors_types.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/src/Errors_types.h	2013-11-22 21:43:19 +0000
@@ -0,0 +1,179 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#ifndef Errors_TYPES_H
+#define Errors_TYPES_H
+
+#include <Thrift.h>
+#include <TApplicationException.h>
+#include <protocol/TProtocol.h>
+#include <transport/TTransport.h>
+
+
+
+namespace evernote { namespace edam {
+
+struct EDAMErrorCode {
+  enum type {
+    UNKNOWN = 1,
+    BAD_DATA_FORMAT = 2,
+    PERMISSION_DENIED = 3,
+    INTERNAL_ERROR = 4,
+    DATA_REQUIRED = 5,
+    LIMIT_REACHED = 6,
+    QUOTA_REACHED = 7,
+    INVALID_AUTH = 8,
+    AUTH_EXPIRED = 9,
+    DATA_CONFLICT = 10,
+    ENML_VALIDATION = 11,
+    SHARD_UNAVAILABLE = 12,
+    LEN_TOO_SHORT = 13,
+    LEN_TOO_LONG = 14,
+    TOO_FEW = 15,
+    TOO_MANY = 16,
+    UNSUPPORTED_OPERATION = 17,
+    TAKEN_DOWN = 18,
+    RATE_LIMIT_REACHED = 19
+  };
+};
+
+typedef struct _EDAMUserException__isset {
+  _EDAMUserException__isset() : parameter(false) {}
+  bool parameter;
+} _EDAMUserException__isset;
+
+class EDAMUserException : public ::apache::thrift::TException {
+ public:
+
+  static const char* ascii_fingerprint; // = "24652790C81ECE22B629CB60A19F1E93";
+  static const uint8_t binary_fingerprint[16]; // = {0x24,0x65,0x27,0x90,0xC8,0x1E,0xCE,0x22,0xB6,0x29,0xCB,0x60,0xA1,0x9F,0x1E,0x93};
+
+  EDAMUserException() : parameter("") {
+  }
+
+  virtual ~EDAMUserException() throw() {}
+
+  EDAMErrorCode::type errorCode;
+  std::string parameter;
+
+  _EDAMUserException__isset __isset;
+
+  bool operator == (const EDAMUserException & rhs) const
+  {
+    if (!(errorCode == rhs.errorCode))
+      return false;
+    if (__isset.parameter != rhs.__isset.parameter)
+      return false;
+    else if (__isset.parameter && !(parameter == rhs.parameter))
+      return false;
+    return true;
+  }
+  bool operator != (const EDAMUserException &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const EDAMUserException & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _EDAMSystemException__isset {
+  _EDAMSystemException__isset() : message(false), rateLimitDuration(false) {}
+  bool message;
+  bool rateLimitDuration;
+} _EDAMSystemException__isset;
+
+class EDAMSystemException : public ::apache::thrift::TException {
+ public:
+
+  static const char* ascii_fingerprint; // = "106D9EB644563D065C091D0BD32D7D44";
+  static const uint8_t binary_fingerprint[16]; // = {0x10,0x6D,0x9E,0xB6,0x44,0x56,0x3D,0x06,0x5C,0x09,0x1D,0x0B,0xD3,0x2D,0x7D,0x44};
+
+  EDAMSystemException() : message(""), rateLimitDuration(0) {
+  }
+
+  virtual ~EDAMSystemException() throw() {}
+
+  EDAMErrorCode::type errorCode;
+  std::string message;
+  int32_t rateLimitDuration;
+
+  _EDAMSystemException__isset __isset;
+
+  bool operator == (const EDAMSystemException & rhs) const
+  {
+    if (!(errorCode == rhs.errorCode))
+      return false;
+    if (__isset.message != rhs.__isset.message)
+      return false;
+    else if (__isset.message && !(message == rhs.message))
+      return false;
+    if (__isset.rateLimitDuration != rhs.__isset.rateLimitDuration)
+      return false;
+    else if (__isset.rateLimitDuration && !(rateLimitDuration == rhs.rateLimitDuration))
+      return false;
+    return true;
+  }
+  bool operator != (const EDAMSystemException &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const EDAMSystemException & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _EDAMNotFoundException__isset {
+  _EDAMNotFoundException__isset() : identifier(false), key(false) {}
+  bool identifier;
+  bool key;
+} _EDAMNotFoundException__isset;
+
+class EDAMNotFoundException : public ::apache::thrift::TException {
+ public:
+
+  static const char* ascii_fingerprint; // = "D0297FC5011701BD87898CC36146A565";
+  static const uint8_t binary_fingerprint[16]; // = {0xD0,0x29,0x7F,0xC5,0x01,0x17,0x01,0xBD,0x87,0x89,0x8C,0xC3,0x61,0x46,0xA5,0x65};
+
+  EDAMNotFoundException() : identifier(""), key("") {
+  }
+
+  virtual ~EDAMNotFoundException() throw() {}
+
+  std::string identifier;
+  std::string key;
+
+  _EDAMNotFoundException__isset __isset;
+
+  bool operator == (const EDAMNotFoundException & rhs) const
+  {
+    if (__isset.identifier != rhs.__isset.identifier)
+      return false;
+    else if (__isset.identifier && !(identifier == rhs.identifier))
+      return false;
+    if (__isset.key != rhs.__isset.key)
+      return false;
+    else if (__isset.key && !(key == rhs.key))
+      return false;
+    return true;
+  }
+  bool operator != (const EDAMNotFoundException &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const EDAMNotFoundException & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+}} // namespace
+
+#endif

=== added file '3rdParty/evernote-sdk-cpp/src/Limits_constants.cpp'
--- 3rdParty/evernote-sdk-cpp/src/Limits_constants.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/src/Limits_constants.cpp	2013-11-22 21:43:19 +0000
@@ -0,0 +1,320 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#include "Limits_constants.h"
+
+namespace evernote { namespace limits {
+
+const LimitsConstants g_Limits_constants;
+
+LimitsConstants::LimitsConstants() {
+  EDAM_ATTRIBUTE_LEN_MIN = 1;
+
+  EDAM_ATTRIBUTE_LEN_MAX = 4096;
+
+  EDAM_ATTRIBUTE_REGEX = "^[^\\p{Cc}\\p{Zl}\\p{Zp}]{1,4096}$";
+
+  EDAM_ATTRIBUTE_LIST_MAX = 100;
+
+  EDAM_ATTRIBUTE_MAP_MAX = 100;
+
+  EDAM_GUID_LEN_MIN = 36;
+
+  EDAM_GUID_LEN_MAX = 36;
+
+  EDAM_GUID_REGEX = "^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$";
+
+  EDAM_EMAIL_LEN_MIN = 6;
+
+  EDAM_EMAIL_LEN_MAX = 255;
+
+  EDAM_EMAIL_LOCAL_REGEX = "^[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+(\\.[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+)*$";
+
+  EDAM_EMAIL_DOMAIN_REGEX = "^[A-Za-z0-9-]+(\\.[A-Za-z0-9-]+)*\\.([A-Za-z]{2,})$";
+
+  EDAM_EMAIL_REGEX = "^[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+(\\.[A-Za-z0-9!#$%&'*+/=?^_`{|}~-]+)*@[A-Za-z0-9-]+(\\.[A-Za-z0-9-]+)*\\.([A-Za-z]{2,})$";
+
+  EDAM_VAT_REGEX = "^((AT)?U[0-9]{8}|(BE)?0?[0-9]{9}|(BG)?[0-9]{9,10}|(CY)?[0-9]{8}L|(CZ)?[0-9]{8,10}|(DE)?[0-9]{9}|(DK)?[0-9]{8}|(EE)?[0-9]{9}|(EL|GR)?[0-9]{9}|(ES)?[0-9A-Z][0-9]{7}[0-9A-Z]|(FI)?[0-9]{8}|(FR)?[0-9A-Z]{2}[0-9]{9}|(GB)?([0-9]{9}([0-9]{3})?|[A-Z]{2}[0-9]{3})|(HU)?[0-9]{8}|(IE)?[0-9]S[0-9]{5}L|(IT)?[0-9]{11}|(LT)?([0-9]{9}|[0-9]{12})|(LU)?[0-9]{8}|(LV)?[0-9]{11}|(MT)?[0-9]{8}|(NL)?[0-9]{9}B[0-9]{2}|(PL)?[0-9]{10}|(PT)?[0-9]{9}|(RO)?[0-9]{2,10}|(SE)?[0-9]{12}|(SI)?[0-9]{8}|(SK)?[0-9]{10})|[0-9]{9}MVA|[0-9]{6}|CHE[0-9]{9}(TVA|MWST|IVA)$";
+
+  EDAM_TIMEZONE_LEN_MIN = 1;
+
+  EDAM_TIMEZONE_LEN_MAX = 32;
+
+  EDAM_TIMEZONE_REGEX = "^([A-Za-z_-]+(/[A-Za-z_-]+)*)|(GMT(-|\\+)[0-9]{1,2}(:[0-9]{2})?)$";
+
+  EDAM_MIME_LEN_MIN = 3;
+
+  EDAM_MIME_LEN_MAX = 255;
+
+  EDAM_MIME_REGEX = "^[A-Za-z]+/[A-Za-z0-9._+-]+$";
+
+  EDAM_MIME_TYPE_GIF = "image/gif";
+
+  EDAM_MIME_TYPE_JPEG = "image/jpeg";
+
+  EDAM_MIME_TYPE_PNG = "image/png";
+
+  EDAM_MIME_TYPE_WAV = "audio/wav";
+
+  EDAM_MIME_TYPE_MP3 = "audio/mpeg";
+
+  EDAM_MIME_TYPE_AMR = "audio/amr";
+
+  EDAM_MIME_TYPE_AAC = "audio/aac";
+
+  EDAM_MIME_TYPE_M4A = "audio/mp4";
+
+  EDAM_MIME_TYPE_MP4_VIDEO = "video/mp4";
+
+  EDAM_MIME_TYPE_INK = "application/vnd.evernote.ink";
+
+  EDAM_MIME_TYPE_PDF = "application/pdf";
+
+  EDAM_MIME_TYPE_DEFAULT = "application/octet-stream";
+
+  EDAM_MIME_TYPES.insert("image/gif");
+  EDAM_MIME_TYPES.insert("image/jpeg");
+  EDAM_MIME_TYPES.insert("image/png");
+  EDAM_MIME_TYPES.insert("audio/wav");
+  EDAM_MIME_TYPES.insert("audio/mpeg");
+  EDAM_MIME_TYPES.insert("audio/amr");
+  EDAM_MIME_TYPES.insert("application/vnd.evernote.ink");
+  EDAM_MIME_TYPES.insert("application/pdf");
+  EDAM_MIME_TYPES.insert("video/mp4");
+  EDAM_MIME_TYPES.insert("audio/aac");
+  EDAM_MIME_TYPES.insert("audio/mp4");
+
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/msword");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/mspowerpoint");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/excel");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/vnd.ms-word");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/vnd.ms-powerpoint");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/vnd.ms-excel");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/vnd.openxmlformats-officedocument.wordprocessingml.document");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/vnd.openxmlformats-officedocument.presentationml.presentation");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/vnd.openxmlformats-officedocument.spreadsheetml.sheet");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/vnd.apple.pages");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/vnd.apple.numbers");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/vnd.apple.keynote");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/x-iwork-pages-sffpages");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/x-iwork-numbers-sffnumbers");
+  EDAM_INDEXABLE_RESOURCE_MIME_TYPES.insert("application/x-iwork-keynote-sffkey");
+
+  EDAM_SEARCH_QUERY_LEN_MIN = 0;
+
+  EDAM_SEARCH_QUERY_LEN_MAX = 1024;
+
+  EDAM_SEARCH_QUERY_REGEX = "^[^\\p{Cc}\\p{Zl}\\p{Zp}]{0,1024}$";
+
+  EDAM_HASH_LEN = 16;
+
+  EDAM_USER_USERNAME_LEN_MIN = 1;
+
+  EDAM_USER_USERNAME_LEN_MAX = 64;
+
+  EDAM_USER_USERNAME_REGEX = "^[a-z0-9]([a-z0-9_-]{0,62}[a-z0-9])?$";
+
+  EDAM_USER_NAME_LEN_MIN = 1;
+
+  EDAM_USER_NAME_LEN_MAX = 255;
+
+  EDAM_USER_NAME_REGEX = "^[^\\p{Cc}\\p{Zl}\\p{Zp}]{1,255}$";
+
+  EDAM_TAG_NAME_LEN_MIN = 1;
+
+  EDAM_TAG_NAME_LEN_MAX = 100;
+
+  EDAM_TAG_NAME_REGEX = "^[^,\\p{Cc}\\p{Z}]([^,\\p{Cc}\\p{Zl}\\p{Zp}]{0,98}[^,\\p{Cc}\\p{Z}])?$";
+
+  EDAM_NOTE_TITLE_LEN_MIN = 1;
+
+  EDAM_NOTE_TITLE_LEN_MAX = 255;
+
+  EDAM_NOTE_TITLE_REGEX = "^[^\\p{Cc}\\p{Z}]([^\\p{Cc}\\p{Zl}\\p{Zp}]{0,253}[^\\p{Cc}\\p{Z}])?$";
+
+  EDAM_NOTE_CONTENT_LEN_MIN = 0;
+
+  EDAM_NOTE_CONTENT_LEN_MAX = 5242880;
+
+  EDAM_APPLICATIONDATA_NAME_LEN_MIN = 3;
+
+  EDAM_APPLICATIONDATA_NAME_LEN_MAX = 32;
+
+  EDAM_APPLICATIONDATA_VALUE_LEN_MIN = 0;
+
+  EDAM_APPLICATIONDATA_VALUE_LEN_MAX = 4092;
+
+  EDAM_APPLICATIONDATA_ENTRY_LEN_MAX = 4095;
+
+  EDAM_APPLICATIONDATA_NAME_REGEX = "^[A-Za-z0-9_.-]{3,32}$";
+
+  EDAM_APPLICATIONDATA_VALUE_REGEX = "^[^\\p{Cc}]{0,4092}$";
+
+  EDAM_NOTEBOOK_NAME_LEN_MIN = 1;
+
+  EDAM_NOTEBOOK_NAME_LEN_MAX = 100;
+
+  EDAM_NOTEBOOK_NAME_REGEX = "^[^\\p{Cc}\\p{Z}]([^\\p{Cc}\\p{Zl}\\p{Zp}]{0,98}[^\\p{Cc}\\p{Z}])?$";
+
+  EDAM_NOTEBOOK_STACK_LEN_MIN = 1;
+
+  EDAM_NOTEBOOK_STACK_LEN_MAX = 100;
+
+  EDAM_NOTEBOOK_STACK_REGEX = "^[^\\p{Cc}\\p{Z}]([^\\p{Cc}\\p{Zl}\\p{Zp}]{0,98}[^\\p{Cc}\\p{Z}])?$";
+
+  EDAM_PUBLISHING_URI_LEN_MIN = 1;
+
+  EDAM_PUBLISHING_URI_LEN_MAX = 255;
+
+  EDAM_PUBLISHING_URI_REGEX = "^[a-zA-Z0-9.~_+-]{1,255}$";
+
+  EDAM_PUBLISHING_URI_PROHIBITED.insert("..");
+
+  EDAM_PUBLISHING_DESCRIPTION_LEN_MIN = 1;
+
+  EDAM_PUBLISHING_DESCRIPTION_LEN_MAX = 200;
+
+  EDAM_PUBLISHING_DESCRIPTION_REGEX = "^[^\\p{Cc}\\p{Z}]([^\\p{Cc}\\p{Zl}\\p{Zp}]{0,198}[^\\p{Cc}\\p{Z}])?$";
+
+  EDAM_SAVED_SEARCH_NAME_LEN_MIN = 1;
+
+  EDAM_SAVED_SEARCH_NAME_LEN_MAX = 100;
+
+  EDAM_SAVED_SEARCH_NAME_REGEX = "^[^\\p{Cc}\\p{Z}]([^\\p{Cc}\\p{Zl}\\p{Zp}]{0,98}[^\\p{Cc}\\p{Z}])?$";
+
+  EDAM_USER_PASSWORD_LEN_MIN = 6;
+
+  EDAM_USER_PASSWORD_LEN_MAX = 64;
+
+  EDAM_USER_PASSWORD_REGEX = "^[A-Za-z0-9!#$%&'()*+,./:;<=>?@^_`{|}~\\[\\]\\\\-]{6,64}$";
+
+  EDAM_BUSINESS_URI_LEN_MAX = 32;
+
+  EDAM_NOTE_TAGS_MAX = 100;
+
+  EDAM_NOTE_RESOURCES_MAX = 1000;
+
+  EDAM_USER_TAGS_MAX = 100000;
+
+  EDAM_BUSINESS_TAGS_MAX = 100000;
+
+  EDAM_USER_SAVED_SEARCHES_MAX = 100;
+
+  EDAM_USER_NOTES_MAX = 100000;
+
+  EDAM_BUSINESS_NOTES_MAX = 500000;
+
+  EDAM_USER_NOTEBOOKS_MAX = 250;
+
+  EDAM_BUSINESS_NOTEBOOKS_MAX = 5000;
+
+  EDAM_USER_RECENT_MAILED_ADDRESSES_MAX = 10;
+
+  EDAM_USER_MAIL_LIMIT_DAILY_FREE = 50;
+
+  EDAM_USER_MAIL_LIMIT_DAILY_PREMIUM = 200;
+
+  EDAM_USER_UPLOAD_LIMIT_FREE = 62914560LL;
+
+  EDAM_USER_UPLOAD_LIMIT_PREMIUM = 1073741824LL;
+
+  EDAM_USER_UPLOAD_LIMIT_BUSINESS = 2147483647LL;
+
+  EDAM_NOTE_SIZE_MAX_FREE = 26214400;
+
+  EDAM_NOTE_SIZE_MAX_PREMIUM = 104857600;
+
+  EDAM_RESOURCE_SIZE_MAX_FREE = 26214400;
+
+  EDAM_RESOURCE_SIZE_MAX_PREMIUM = 104857600;
+
+  EDAM_USER_LINKED_NOTEBOOK_MAX = 100;
+
+  EDAM_USER_LINKED_NOTEBOOK_MAX_PREMIUM = 250;
+
+  EDAM_NOTEBOOK_SHARED_NOTEBOOK_MAX = 250;
+
+  EDAM_NOTE_CONTENT_CLASS_LEN_MIN = 3;
+
+  EDAM_NOTE_CONTENT_CLASS_LEN_MAX = 32;
+
+  EDAM_NOTE_CONTENT_CLASS_REGEX = "^[A-Za-z0-9_.-]{3,32}$";
+
+  EDAM_HELLO_APP_CONTENT_CLASS_PREFIX = "evernote.hello.";
+
+  EDAM_FOOD_APP_CONTENT_CLASS_PREFIX = "evernote.food.";
+
+  EDAM_CONTENT_CLASS_HELLO_ENCOUNTER = "evernote.hello.encounter";
+
+  EDAM_CONTENT_CLASS_HELLO_PROFILE = "evernote.hello.profile";
+
+  EDAM_CONTENT_CLASS_FOOD_MEAL = "evernote.food.meal";
+
+  EDAM_CONTENT_CLASS_SKITCH_PREFIX = "evernote.skitch";
+
+  EDAM_CONTENT_CLASS_SKITCH = "evernote.skitch";
+
+  EDAM_CONTENT_CLASS_SKITCH_PDF = "evernote.skitch.pdf";
+
+  EDAM_CONTENT_CLASS_PENULTIMATE_PREFIX = "evernote.penultimate.";
+
+  EDAM_CONTENT_CLASS_PENULTIMATE_NOTEBOOK = "evernote.penultimate.notebook";
+
+  EDAM_RELATED_PLAINTEXT_LEN_MIN = 1;
+
+  EDAM_RELATED_PLAINTEXT_LEN_MAX = 131072;
+
+  EDAM_RELATED_MAX_NOTES = 25;
+
+  EDAM_RELATED_MAX_NOTEBOOKS = 1;
+
+  EDAM_RELATED_MAX_TAGS = 25;
+
+  EDAM_BUSINESS_NOTEBOOK_DESCRIPTION_LEN_MIN = 1;
+
+  EDAM_BUSINESS_NOTEBOOK_DESCRIPTION_LEN_MAX = 200;
+
+  EDAM_BUSINESS_NOTEBOOK_DESCRIPTION_REGEX = "^[^\\p{Cc}\\p{Z}]([^\\p{Cc}\\p{Zl}\\p{Zp}]{0,198}[^\\p{Cc}\\p{Z}])?$";
+
+  EDAM_BUSINESS_PHONE_NUMBER_LEN_MAX = 20;
+
+  EDAM_PREFERENCE_NAME_LEN_MIN = 3;
+
+  EDAM_PREFERENCE_NAME_LEN_MAX = 32;
+
+  EDAM_PREFERENCE_VALUE_LEN_MIN = 1;
+
+  EDAM_PREFERENCE_VALUE_LEN_MAX = 1024;
+
+  EDAM_MAX_PREFERENCES = 100;
+
+  EDAM_MAX_VALUES_PER_PREFERENCE = 256;
+
+  EDAM_PREFERENCE_NAME_REGEX = "^[A-Za-z0-9_.-]{3,32}$";
+
+  EDAM_PREFERENCE_VALUE_REGEX = "^[^\\p{Cc}]{1,1024}$";
+
+  EDAM_PREFERENCE_SHORTCUTS = "evernote.shortcuts";
+
+  EDAM_PREFERENCE_SHORTCUTS_MAX_VALUES = 250;
+
+  EDAM_DEVICE_ID_LEN_MAX = 32;
+
+  EDAM_DEVICE_ID_REGEX = "^[^\\p{Cc}]{1,32}$";
+
+  EDAM_DEVICE_DESCRIPTION_LEN_MAX = 64;
+
+  EDAM_DEVICE_DESCRIPTION_REGEX = "^[^\\p{Cc}]{1,64}$";
+
+  EDAM_SEARCH_SUGGESTIONS_MAX = 10;
+
+  EDAM_SEARCH_SUGGESTIONS_PREFIX_LEN_MAX = 1024;
+
+  EDAM_SEARCH_SUGGESTIONS_PREFIX_LEN_MIN = 2;
+
+}
+
+}} // namespace
+

=== added file '3rdParty/evernote-sdk-cpp/src/Limits_constants.h'
--- 3rdParty/evernote-sdk-cpp/src/Limits_constants.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/src/Limits_constants.h	2013-11-22 21:43:19 +0000
@@ -0,0 +1,163 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#ifndef Limits_CONSTANTS_H
+#define Limits_CONSTANTS_H
+
+#include "Limits_types.h"
+
+namespace evernote { namespace limits {
+
+class LimitsConstants {
+ public:
+  LimitsConstants();
+
+  int32_t EDAM_ATTRIBUTE_LEN_MIN;
+  int32_t EDAM_ATTRIBUTE_LEN_MAX;
+  std::string EDAM_ATTRIBUTE_REGEX;
+  int32_t EDAM_ATTRIBUTE_LIST_MAX;
+  int32_t EDAM_ATTRIBUTE_MAP_MAX;
+  int32_t EDAM_GUID_LEN_MIN;
+  int32_t EDAM_GUID_LEN_MAX;
+  std::string EDAM_GUID_REGEX;
+  int32_t EDAM_EMAIL_LEN_MIN;
+  int32_t EDAM_EMAIL_LEN_MAX;
+  std::string EDAM_EMAIL_LOCAL_REGEX;
+  std::string EDAM_EMAIL_DOMAIN_REGEX;
+  std::string EDAM_EMAIL_REGEX;
+  std::string EDAM_VAT_REGEX;
+  int32_t EDAM_TIMEZONE_LEN_MIN;
+  int32_t EDAM_TIMEZONE_LEN_MAX;
+  std::string EDAM_TIMEZONE_REGEX;
+  int32_t EDAM_MIME_LEN_MIN;
+  int32_t EDAM_MIME_LEN_MAX;
+  std::string EDAM_MIME_REGEX;
+  std::string EDAM_MIME_TYPE_GIF;
+  std::string EDAM_MIME_TYPE_JPEG;
+  std::string EDAM_MIME_TYPE_PNG;
+  std::string EDAM_MIME_TYPE_WAV;
+  std::string EDAM_MIME_TYPE_MP3;
+  std::string EDAM_MIME_TYPE_AMR;
+  std::string EDAM_MIME_TYPE_AAC;
+  std::string EDAM_MIME_TYPE_M4A;
+  std::string EDAM_MIME_TYPE_MP4_VIDEO;
+  std::string EDAM_MIME_TYPE_INK;
+  std::string EDAM_MIME_TYPE_PDF;
+  std::string EDAM_MIME_TYPE_DEFAULT;
+  std::set<std::string>  EDAM_MIME_TYPES;
+  std::set<std::string>  EDAM_INDEXABLE_RESOURCE_MIME_TYPES;
+  int32_t EDAM_SEARCH_QUERY_LEN_MIN;
+  int32_t EDAM_SEARCH_QUERY_LEN_MAX;
+  std::string EDAM_SEARCH_QUERY_REGEX;
+  int32_t EDAM_HASH_LEN;
+  int32_t EDAM_USER_USERNAME_LEN_MIN;
+  int32_t EDAM_USER_USERNAME_LEN_MAX;
+  std::string EDAM_USER_USERNAME_REGEX;
+  int32_t EDAM_USER_NAME_LEN_MIN;
+  int32_t EDAM_USER_NAME_LEN_MAX;
+  std::string EDAM_USER_NAME_REGEX;
+  int32_t EDAM_TAG_NAME_LEN_MIN;
+  int32_t EDAM_TAG_NAME_LEN_MAX;
+  std::string EDAM_TAG_NAME_REGEX;
+  int32_t EDAM_NOTE_TITLE_LEN_MIN;
+  int32_t EDAM_NOTE_TITLE_LEN_MAX;
+  std::string EDAM_NOTE_TITLE_REGEX;
+  int32_t EDAM_NOTE_CONTENT_LEN_MIN;
+  int32_t EDAM_NOTE_CONTENT_LEN_MAX;
+  int32_t EDAM_APPLICATIONDATA_NAME_LEN_MIN;
+  int32_t EDAM_APPLICATIONDATA_NAME_LEN_MAX;
+  int32_t EDAM_APPLICATIONDATA_VALUE_LEN_MIN;
+  int32_t EDAM_APPLICATIONDATA_VALUE_LEN_MAX;
+  int32_t EDAM_APPLICATIONDATA_ENTRY_LEN_MAX;
+  std::string EDAM_APPLICATIONDATA_NAME_REGEX;
+  std::string EDAM_APPLICATIONDATA_VALUE_REGEX;
+  int32_t EDAM_NOTEBOOK_NAME_LEN_MIN;
+  int32_t EDAM_NOTEBOOK_NAME_LEN_MAX;
+  std::string EDAM_NOTEBOOK_NAME_REGEX;
+  int32_t EDAM_NOTEBOOK_STACK_LEN_MIN;
+  int32_t EDAM_NOTEBOOK_STACK_LEN_MAX;
+  std::string EDAM_NOTEBOOK_STACK_REGEX;
+  int32_t EDAM_PUBLISHING_URI_LEN_MIN;
+  int32_t EDAM_PUBLISHING_URI_LEN_MAX;
+  std::string EDAM_PUBLISHING_URI_REGEX;
+  std::set<std::string>  EDAM_PUBLISHING_URI_PROHIBITED;
+  int32_t EDAM_PUBLISHING_DESCRIPTION_LEN_MIN;
+  int32_t EDAM_PUBLISHING_DESCRIPTION_LEN_MAX;
+  std::string EDAM_PUBLISHING_DESCRIPTION_REGEX;
+  int32_t EDAM_SAVED_SEARCH_NAME_LEN_MIN;
+  int32_t EDAM_SAVED_SEARCH_NAME_LEN_MAX;
+  std::string EDAM_SAVED_SEARCH_NAME_REGEX;
+  int32_t EDAM_USER_PASSWORD_LEN_MIN;
+  int32_t EDAM_USER_PASSWORD_LEN_MAX;
+  std::string EDAM_USER_PASSWORD_REGEX;
+  int32_t EDAM_BUSINESS_URI_LEN_MAX;
+  int32_t EDAM_NOTE_TAGS_MAX;
+  int32_t EDAM_NOTE_RESOURCES_MAX;
+  int32_t EDAM_USER_TAGS_MAX;
+  int32_t EDAM_BUSINESS_TAGS_MAX;
+  int32_t EDAM_USER_SAVED_SEARCHES_MAX;
+  int32_t EDAM_USER_NOTES_MAX;
+  int32_t EDAM_BUSINESS_NOTES_MAX;
+  int32_t EDAM_USER_NOTEBOOKS_MAX;
+  int32_t EDAM_BUSINESS_NOTEBOOKS_MAX;
+  int32_t EDAM_USER_RECENT_MAILED_ADDRESSES_MAX;
+  int32_t EDAM_USER_MAIL_LIMIT_DAILY_FREE;
+  int32_t EDAM_USER_MAIL_LIMIT_DAILY_PREMIUM;
+  int64_t EDAM_USER_UPLOAD_LIMIT_FREE;
+  int64_t EDAM_USER_UPLOAD_LIMIT_PREMIUM;
+  int64_t EDAM_USER_UPLOAD_LIMIT_BUSINESS;
+  int32_t EDAM_NOTE_SIZE_MAX_FREE;
+  int32_t EDAM_NOTE_SIZE_MAX_PREMIUM;
+  int32_t EDAM_RESOURCE_SIZE_MAX_FREE;
+  int32_t EDAM_RESOURCE_SIZE_MAX_PREMIUM;
+  int32_t EDAM_USER_LINKED_NOTEBOOK_MAX;
+  int32_t EDAM_USER_LINKED_NOTEBOOK_MAX_PREMIUM;
+  int32_t EDAM_NOTEBOOK_SHARED_NOTEBOOK_MAX;
+  int32_t EDAM_NOTE_CONTENT_CLASS_LEN_MIN;
+  int32_t EDAM_NOTE_CONTENT_CLASS_LEN_MAX;
+  std::string EDAM_NOTE_CONTENT_CLASS_REGEX;
+  std::string EDAM_HELLO_APP_CONTENT_CLASS_PREFIX;
+  std::string EDAM_FOOD_APP_CONTENT_CLASS_PREFIX;
+  std::string EDAM_CONTENT_CLASS_HELLO_ENCOUNTER;
+  std::string EDAM_CONTENT_CLASS_HELLO_PROFILE;
+  std::string EDAM_CONTENT_CLASS_FOOD_MEAL;
+  std::string EDAM_CONTENT_CLASS_SKITCH_PREFIX;
+  std::string EDAM_CONTENT_CLASS_SKITCH;
+  std::string EDAM_CONTENT_CLASS_SKITCH_PDF;
+  std::string EDAM_CONTENT_CLASS_PENULTIMATE_PREFIX;
+  std::string EDAM_CONTENT_CLASS_PENULTIMATE_NOTEBOOK;
+  int32_t EDAM_RELATED_PLAINTEXT_LEN_MIN;
+  int32_t EDAM_RELATED_PLAINTEXT_LEN_MAX;
+  int32_t EDAM_RELATED_MAX_NOTES;
+  int32_t EDAM_RELATED_MAX_NOTEBOOKS;
+  int32_t EDAM_RELATED_MAX_TAGS;
+  int32_t EDAM_BUSINESS_NOTEBOOK_DESCRIPTION_LEN_MIN;
+  int32_t EDAM_BUSINESS_NOTEBOOK_DESCRIPTION_LEN_MAX;
+  std::string EDAM_BUSINESS_NOTEBOOK_DESCRIPTION_REGEX;
+  int32_t EDAM_BUSINESS_PHONE_NUMBER_LEN_MAX;
+  int32_t EDAM_PREFERENCE_NAME_LEN_MIN;
+  int32_t EDAM_PREFERENCE_NAME_LEN_MAX;
+  int32_t EDAM_PREFERENCE_VALUE_LEN_MIN;
+  int32_t EDAM_PREFERENCE_VALUE_LEN_MAX;
+  int32_t EDAM_MAX_PREFERENCES;
+  int32_t EDAM_MAX_VALUES_PER_PREFERENCE;
+  std::string EDAM_PREFERENCE_NAME_REGEX;
+  std::string EDAM_PREFERENCE_VALUE_REGEX;
+  std::string EDAM_PREFERENCE_SHORTCUTS;
+  int32_t EDAM_PREFERENCE_SHORTCUTS_MAX_VALUES;
+  int32_t EDAM_DEVICE_ID_LEN_MAX;
+  std::string EDAM_DEVICE_ID_REGEX;
+  int32_t EDAM_DEVICE_DESCRIPTION_LEN_MAX;
+  std::string EDAM_DEVICE_DESCRIPTION_REGEX;
+  int32_t EDAM_SEARCH_SUGGESTIONS_MAX;
+  int32_t EDAM_SEARCH_SUGGESTIONS_PREFIX_LEN_MAX;
+  int32_t EDAM_SEARCH_SUGGESTIONS_PREFIX_LEN_MIN;
+};
+
+extern const LimitsConstants g_Limits_constants;
+
+}} // namespace
+
+#endif

=== added file '3rdParty/evernote-sdk-cpp/src/Limits_types.cpp'
--- 3rdParty/evernote-sdk-cpp/src/Limits_types.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/src/Limits_types.cpp	2013-11-22 21:43:19 +0000
@@ -0,0 +1,10 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#include "Limits_types.h"
+
+namespace evernote { namespace limits {
+
+}} // namespace

=== added file '3rdParty/evernote-sdk-cpp/src/Limits_types.h'
--- 3rdParty/evernote-sdk-cpp/src/Limits_types.h	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/src/Limits_types.h	2013-11-22 21:43:19 +0000
@@ -0,0 +1,20 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#ifndef Limits_TYPES_H
+#define Limits_TYPES_H
+
+#include <Thrift.h>
+#include <TApplicationException.h>
+#include <protocol/TProtocol.h>
+#include <transport/TTransport.h>
+
+
+
+namespace evernote { namespace limits {
+
+}} // namespace
+
+#endif

=== added file '3rdParty/evernote-sdk-cpp/src/NoteStore.cpp'
--- 3rdParty/evernote-sdk-cpp/src/NoteStore.cpp	1970-01-01 00:00:00 +0000
+++ 3rdParty/evernote-sdk-cpp/src/NoteStore.cpp	2013-11-22 21:43:19 +0000
@@ -0,0 +1,25986 @@
+/**
+ * Autogenerated by Thrift
+ *
+ * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+ */
+#include "NoteStore.h"
+
+namespace evernote { namespace edam {
+
+uint32_t NoteStore_getSyncState_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncState_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getSyncState_args");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->authenticationToken);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncState_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getSyncState_pargs");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->authenticationToken)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncState_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncState_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("NoteStore_getSyncState_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.userException) {
+    xfer += oprot->writeFieldBegin("userException", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->userException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.systemException) {
+    xfer += oprot->writeFieldBegin("systemException", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->systemException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncState_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncStateWithMetrics_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->clientMetrics.read(iprot);
+          this->__isset.clientMetrics = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncStateWithMetrics_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getSyncStateWithMetrics_args");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->authenticationToken);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("clientMetrics", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->clientMetrics.write(oprot);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncStateWithMetrics_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getSyncStateWithMetrics_pargs");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->authenticationToken)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("clientMetrics", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->clientMetrics)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncStateWithMetrics_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncStateWithMetrics_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("NoteStore_getSyncStateWithMetrics_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.userException) {
+    xfer += oprot->writeFieldBegin("userException", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->userException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.systemException) {
+    xfer += oprot->writeFieldBegin("systemException", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->systemException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncStateWithMetrics_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncChunk_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->afterUSN);
+          this->__isset.afterUSN = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->maxEntries);
+          this->__isset.maxEntries = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->fullSyncOnly);
+          this->__isset.fullSyncOnly = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncChunk_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getSyncChunk_args");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->authenticationToken);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("afterUSN", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32(this->afterUSN);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("maxEntries", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32(this->maxEntries);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("fullSyncOnly", ::apache::thrift::protocol::T_BOOL, 4);
+  xfer += oprot->writeBool(this->fullSyncOnly);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncChunk_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getSyncChunk_pargs");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->authenticationToken)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("afterUSN", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32((*(this->afterUSN)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("maxEntries", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32((*(this->maxEntries)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("fullSyncOnly", ::apache::thrift::protocol::T_BOOL, 4);
+  xfer += oprot->writeBool((*(this->fullSyncOnly)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncChunk_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncChunk_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("NoteStore_getSyncChunk_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.userException) {
+    xfer += oprot->writeFieldBegin("userException", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->userException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.systemException) {
+    xfer += oprot->writeFieldBegin("systemException", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->systemException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getSyncChunk_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getFilteredSyncChunk_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->afterUSN);
+          this->__isset.afterUSN = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->maxEntries);
+          this->__isset.maxEntries = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->filter.read(iprot);
+          this->__isset.filter = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getFilteredSyncChunk_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getFilteredSyncChunk_args");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->authenticationToken);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("afterUSN", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32(this->afterUSN);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("maxEntries", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32(this->maxEntries);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRUCT, 4);
+  xfer += this->filter.write(oprot);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getFilteredSyncChunk_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getFilteredSyncChunk_pargs");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->authenticationToken)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("afterUSN", ::apache::thrift::protocol::T_I32, 2);
+  xfer += oprot->writeI32((*(this->afterUSN)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("maxEntries", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32((*(this->maxEntries)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("filter", ::apache::thrift::protocol::T_STRUCT, 4);
+  xfer += (*(this->filter)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getFilteredSyncChunk_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getFilteredSyncChunk_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("NoteStore_getFilteredSyncChunk_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.userException) {
+    xfer += oprot->writeFieldBegin("userException", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->userException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.systemException) {
+    xfer += oprot->writeFieldBegin("systemException", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->systemException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getFilteredSyncChunk_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getLinkedNotebookSyncState_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->linkedNotebook.read(iprot);
+          this->__isset.linkedNotebook = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getLinkedNotebookSyncState_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getLinkedNotebookSyncState_args");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->authenticationToken);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("linkedNotebook", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->linkedNotebook.write(oprot);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getLinkedNotebookSyncState_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getLinkedNotebookSyncState_pargs");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->authenticationToken)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("linkedNotebook", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->linkedNotebook)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getLinkedNotebookSyncState_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->notFoundException.read(iprot);
+          this->__isset.notFoundException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getLinkedNotebookSyncState_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("NoteStore_getLinkedNotebookSyncState_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.userException) {
+    xfer += oprot->writeFieldBegin("userException", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->userException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.systemException) {
+    xfer += oprot->writeFieldBegin("systemException", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->systemException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.notFoundException) {
+    xfer += oprot->writeFieldBegin("notFoundException", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->notFoundException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getLinkedNotebookSyncState_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->notFoundException.read(iprot);
+          this->__isset.notFoundException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getLinkedNotebookSyncChunk_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->linkedNotebook.read(iprot);
+          this->__isset.linkedNotebook = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->afterUSN);
+          this->__isset.afterUSN = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->maxEntries);
+          this->__isset.maxEntries = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->fullSyncOnly);
+          this->__isset.fullSyncOnly = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getLinkedNotebookSyncChunk_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getLinkedNotebookSyncChunk_args");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->authenticationToken);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("linkedNotebook", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->linkedNotebook.write(oprot);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("afterUSN", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32(this->afterUSN);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("maxEntries", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32(this->maxEntries);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("fullSyncOnly", ::apache::thrift::protocol::T_BOOL, 5);
+  xfer += oprot->writeBool(this->fullSyncOnly);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getLinkedNotebookSyncChunk_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getLinkedNotebookSyncChunk_pargs");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->authenticationToken)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("linkedNotebook", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->linkedNotebook)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("afterUSN", ::apache::thrift::protocol::T_I32, 3);
+  xfer += oprot->writeI32((*(this->afterUSN)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("maxEntries", ::apache::thrift::protocol::T_I32, 4);
+  xfer += oprot->writeI32((*(this->maxEntries)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("fullSyncOnly", ::apache::thrift::protocol::T_BOOL, 5);
+  xfer += oprot->writeBool((*(this->fullSyncOnly)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getLinkedNotebookSyncChunk_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->notFoundException.read(iprot);
+          this->__isset.notFoundException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getLinkedNotebookSyncChunk_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("NoteStore_getLinkedNotebookSyncChunk_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.userException) {
+    xfer += oprot->writeFieldBegin("userException", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->userException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.systemException) {
+    xfer += oprot->writeFieldBegin("systemException", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->systemException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.notFoundException) {
+    xfer += oprot->writeFieldBegin("notFoundException", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->notFoundException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getLinkedNotebookSyncChunk_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->notFoundException.read(iprot);
+          this->__isset.notFoundException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_listNotebooks_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_listNotebooks_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_listNotebooks_args");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->authenticationToken);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_listNotebooks_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_listNotebooks_pargs");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->authenticationToken)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_listNotebooks_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size166;
+            ::apache::thrift::protocol::TType _etype169;
+            iprot->readListBegin(_etype169, _size166);
+            this->success.resize(_size166);
+            uint32_t _i170;
+            for (_i170 = 0; _i170 < _size166; ++_i170)
+            {
+              xfer += this->success[_i170].read(iprot);
+            }
+            iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_listNotebooks_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("NoteStore_listNotebooks_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->success.size());
+      std::vector<evernote::edam::Notebook> ::const_iterator _iter171;
+      for (_iter171 = this->success.begin(); _iter171 != this->success.end(); ++_iter171)
+      {
+        xfer += (*_iter171).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.userException) {
+    xfer += oprot->writeFieldBegin("userException", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->userException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.systemException) {
+    xfer += oprot->writeFieldBegin("systemException", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->systemException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_listNotebooks_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size172;
+            ::apache::thrift::protocol::TType _etype175;
+            iprot->readListBegin(_etype175, _size172);
+            (*(this->success)).resize(_size172);
+            uint32_t _i176;
+            for (_i176 = 0; _i176 < _size172; ++_i176)
+            {
+              xfer += (*(this->success))[_i176].read(iprot);
+            }
+            iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getNotebook_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->guid);
+          this->__isset.guid = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getNotebook_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getNotebook_args");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->authenticationToken);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("guid", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->guid);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getNotebook_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getNotebook_pargs");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->authenticationToken)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("guid", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString((*(this->guid)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getNotebook_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->notFoundException.read(iprot);
+          this->__isset.notFoundException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getNotebook_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("NoteStore_getNotebook_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.userException) {
+    xfer += oprot->writeFieldBegin("userException", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->userException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.systemException) {
+    xfer += oprot->writeFieldBegin("systemException", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->systemException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.notFoundException) {
+    xfer += oprot->writeFieldBegin("notFoundException", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->notFoundException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getNotebook_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->notFoundException.read(iprot);
+          this->__isset.notFoundException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getDefaultNotebook_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getDefaultNotebook_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getDefaultNotebook_args");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->authenticationToken);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getDefaultNotebook_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_getDefaultNotebook_pargs");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->authenticationToken)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getDefaultNotebook_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_getDefaultNotebook_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("NoteStore_getDefaultNotebook_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.userException) {
+    xfer += oprot->writeFieldBegin("userException", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->userException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.systemException) {
+    xfer += oprot->writeFieldBegin("systemException", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->systemException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_getDefaultNotebook_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_createNotebook_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->notebook.read(iprot);
+          this->__isset.notebook = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_createNotebook_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_createNotebook_args");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->authenticationToken);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("notebook", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->notebook.write(oprot);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_createNotebook_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_createNotebook_pargs");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->authenticationToken)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("notebook", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->notebook)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_createNotebook_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->success.read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_createNotebook_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("NoteStore_createNotebook_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+    xfer += this->success.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.userException) {
+    xfer += oprot->writeFieldBegin("userException", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->userException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.systemException) {
+    xfer += oprot->writeFieldBegin("systemException", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->systemException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_createNotebook_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += (*(this->success)).read(iprot);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_updateNotebook_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->notebook.read(iprot);
+          this->__isset.notebook = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_updateNotebook_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_updateNotebook_args");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->authenticationToken);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("notebook", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += this->notebook.write(oprot);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_updateNotebook_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_updateNotebook_pargs");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->authenticationToken)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("notebook", ::apache::thrift::protocol::T_STRUCT, 2);
+  xfer += (*(this->notebook)).write(oprot);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_updateNotebook_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->notFoundException.read(iprot);
+          this->__isset.notFoundException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_updateNotebook_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("NoteStore_updateNotebook_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
+    xfer += oprot->writeI32(this->success);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.userException) {
+    xfer += oprot->writeFieldBegin("userException", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->userException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.systemException) {
+    xfer += oprot->writeFieldBegin("systemException", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->systemException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.notFoundException) {
+    xfer += oprot->writeFieldBegin("notFoundException", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->notFoundException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_updateNotebook_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->notFoundException.read(iprot);
+          this->__isset.notFoundException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_expungeNotebook_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->guid);
+          this->__isset.guid = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_expungeNotebook_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_expungeNotebook_args");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->authenticationToken);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("guid", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->guid);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_expungeNotebook_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_expungeNotebook_pargs");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->authenticationToken)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("guid", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString((*(this->guid)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_expungeNotebook_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32(this->success);
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->notFoundException.read(iprot);
+          this->__isset.notFoundException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_expungeNotebook_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("NoteStore_expungeNotebook_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_I32, 0);
+    xfer += oprot->writeI32(this->success);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.userException) {
+    xfer += oprot->writeFieldBegin("userException", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->userException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.systemException) {
+    xfer += oprot->writeFieldBegin("systemException", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->systemException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.notFoundException) {
+    xfer += oprot->writeFieldBegin("notFoundException", ::apache::thrift::protocol::T_STRUCT, 3);
+    xfer += this->notFoundException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_expungeNotebook_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_I32) {
+          xfer += iprot->readI32((*(this->success)));
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->notFoundException.read(iprot);
+          this->__isset.notFoundException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_listTags_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_listTags_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_listTags_args");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->authenticationToken);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_listTags_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("NoteStore_listTags_pargs");
+  xfer += oprot->writeFieldBegin("authenticationToken", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString((*(this->authenticationToken)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_listTags_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size177;
+            ::apache::thrift::protocol::TType _etype180;
+            iprot->readListBegin(_etype180, _size177);
+            this->success.resize(_size177);
+            uint32_t _i181;
+            for (_i181 = 0; _i181 < _size177; ++_i181)
+            {
+              xfer += this->success[_i181].read(iprot);
+            }
+            iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_listTags_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("NoteStore_listTags_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, this->success.size());
+      std::vector<evernote::edam::Tag> ::const_iterator _iter182;
+      for (_iter182 = this->success.begin(); _iter182 != this->success.end(); ++_iter182)
+      {
+        xfer += (*_iter182).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.userException) {
+    xfer += oprot->writeFieldBegin("userException", ::apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->userException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.systemException) {
+    xfer += oprot->writeFieldBegin("systemException", ::apache::thrift::protocol::T_STRUCT, 2);
+    xfer += this->systemException.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t NoteStore_listTags_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size183;
+            ::apache::thrift::protocol::TType _etype186;
+            iprot->readListBegin(_etype186, _size183);
+            (*(this->success)).resize(_size183);
+            uint32_t _i187;
+            for (_i187 = 0; _i187 < _size183; ++_i187)
+            {
+              xfer += (*(this->success))[_i187].read(iprot);
+            }
+            iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->userException.read(iprot);
+          this->__isset.userException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+          xfer += this->systemException.read(iprot);
+          this->__isset.systemException = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t NoteStore_listTagsByNotebook_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  ::apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using ::apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == ::apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 1:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->authenticationToken);
+          this->__isset.authenticationToken = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->notebookGuid);
+          this->__isset.notebookGuid = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+