Repair to Code Final Commit

Code Burner/Pods/Firebase/Core/Sources/Firebase.h

@@ -0,0 +1,52 @@
+#import <FirebaseAnalytics/FirebaseAnalytics.h>
+#import <FirebaseCore/FirebaseCore.h>
+
+#if !defined(__has_include)
+  #error "Firebase.h won't import anything if your compiler doesn't support __has_include. Please \
+          import the headers individually."
+#else
+  #if __has_include(<FirebaseAppIndexing/FirebaseAppIndexing.h>)
+    #import <FirebaseAppIndexing/FirebaseAppIndexing.h>
+  #endif
+
+  #if __has_include(<FirebaseAuth/FirebaseAuth.h>)
+    #import <FirebaseAuth/FirebaseAuth.h>
+  #endif
+
+  #if __has_include(<FirebaseCrash/FirebaseCrash.h>)
+    #import <FirebaseCrash/FirebaseCrash.h>
+  #endif
+
+  #if __has_include(<FirebaseDatabase/FirebaseDatabase.h>)
+    #import <FirebaseDatabase/FirebaseDatabase.h>
+  #endif
+
+  #if __has_include(<FirebaseDynamicLinks/FirebaseDynamicLinks.h>)
+    #import <FirebaseDynamicLinks/FirebaseDynamicLinks.h>
+  #endif
+
+  #if __has_include(<FirebaseInstanceID/FirebaseInstanceID.h>)
+    #import <FirebaseInstanceID/FirebaseInstanceID.h>
+  #endif
+
+  #if __has_include(<FirebaseInvites/FirebaseInvites.h>)
+    #import <FirebaseInvites/FirebaseInvites.h>
+  #endif
+
+  #if __has_include(<FirebaseMessaging/FirebaseMessaging.h>)
+    #import <FirebaseMessaging/FirebaseMessaging.h>
+  #endif
+
+  #if __has_include(<FirebaseRemoteConfig/FirebaseRemoteConfig.h>)
+    #import <FirebaseRemoteConfig/FirebaseRemoteConfig.h>
+  #endif
+
+  #if __has_include(<FirebaseStorage/FirebaseStorage.h>)
+    #import <FirebaseStorage/FirebaseStorage.h>
+  #endif
+
+  #if __has_include(<GoogleMobileAds/GoogleMobileAds.h>)
+    #import <GoogleMobileAds/GoogleMobileAds.h>
+  #endif
+
+#endif  // defined(__has_include)

Code Burner/Pods/Firebase/Core/Sources/module.modulemap

@@ -0,0 +1,4 @@
+module Firebase {
+  export *
+  header "Firebase.h"
+}

Code Burner/Pods/Firebase/README.md

@@ -0,0 +1,76 @@
+# Firebase APIs for iOS
+
+Simplify your iOS development, grow your user base, and monetize more
+effectively with Firebase services.
+
+Much more information can be found at [https://firebase.google.com](https://firebase.google.com).
+
+## Install a Firebase SDK using CocoaPods
+
+Firebase distributes several iOS specific APIs and SDKs via CocoaPods.
+You can install the CocoaPods tool on OS X by running the following command from
+the terminal. Detailed information is available in the [Getting Started
+guide](https://guides.cocoapods.org/using/getting-started.html#getting-started).
+
+```
+$ sudo gem install cocoapods
+```
+
+## Try out an SDK
+
+You can try any of the SDKs with `pod try`. Run the following command and select
+the SDK you are interested in when prompted:
+
+```
+$ pod try Firebase
+```
+
+Note that some SDKs may require credentials. More information is available in
+the SDK-specific documentation at [https://firebase.google.com/docs/](https://firebase.google.com/docs/).
+
+## Add a Firebase SDK to your iOS app
+
+CocoaPods is used to install and manage dependencies in existing Xcode projects.
+
+1. Create an Xcode project, and save it to your local machine.
+2. Create a file named `Podfile` in your project directory. This file defines
+   your project's dependencies, and is commonly referred to as a Podspec.
+3. Open `Podfile`, and add your dependencies. A simple Podspec is shown here:
+
+    ```
+    platform :ios, '7.0'
+    pod 'Firebase'
+    ```
+
+4. Save the file.
+5. Open a terminal and `cd` to the directory containing the Podfile.
+
+    ```
+    $ cd <path-to-project>/project/
+    ```
+
+6. Run the `pod install` command. This will install the SDKs specified in the
+   Podspec, along with any dependencies they may have.
+
+    ```
+    $ pod install
+    ```
+
+7. Open your app's `.xcworkspace` file to launch Xcode.
+   Use this file for all development on your app.
+8. You can also install other Firebase SDKs by adding the subspecs in the
+   Podfile.
+
+   ```
+   pod 'Firebase/AdMob'
+   pod 'Firebase/Analytics'
+   pod 'Firebase/AppIndexing'
+   pod 'Firebase/Auth'
+   pod 'Firebase/Crash'
+   pod 'Firebase/Database'
+   pod 'Firebase/DynamicLinks'
+   pod 'Firebase/Invites'
+   pod 'Firebase/Messaging'
+   pod 'Firebase/RemoteConfig'
+   pod 'Firebase/Storage'
+   ```

Code Burner/Pods/FirebaseAuth/CHANGELOG.md

@@ -0,0 +1,23 @@
+# 2016-10-24 -- v3.0.6
+- Switches to depend on open sourced GoogleToolboxForMac and GTMSessionFetcher.
+- Improves logging of keychain error when initializing.
+
+# 2016-09-14 -- v3.0.5
+- Works around a keychain issue in iOS 10 simulator.
+- Reports the correct error for invalid email when signing in with email and
+  password.
+
+# 2016-07-18 -- v3.0.4
+- Fixes a race condition bug that could crash the app with an exception from
+  NSURLSession on iOS 9.
+
+# 2016-06-20 -- v3.0.3
+- Adds documentation for all possible errors returned by each method.
+- Improves error handling and messages for a variety of error conditions.
+- Whether or not an user is considered anonymous is now consistent with other
+  platforms.
+- A saved signed in user is now siloed between different Firebase projects
+  within the same app.
+
+# 2016-05-18 -- v3.0.2
+- Initial public release.

Code Burner/Pods/FirebaseAuth/README.md

@@ -0,0 +1,8 @@
+# Firebase Auth for iOS
+
+Firebase Auth enables apps to easily support multiple authentication options
+for their end users.
+
+Please visit [our developer site](https://developers.google.com/) for
+integration instructions, documentation, support information, and terms of
+service.

Code Burner/Pods/FirebaseInstanceID/Sources/FIRInstanceID.h

@@ -0,0 +1,237 @@
+#import <Foundation/Foundation.h>
+
+/**
+ *  @memberof FIRInstanceID
+ *
+ *  The scope to be used when fetching/deleting a token for Firebase Messaging.
+ */
+FOUNDATION_EXPORT NSString * __nonnull const kFIRInstanceIDScopeFirebaseMessaging;
+
+/**
+ *  Called when the system determines that tokens need to be refreshed.
+ *  This method is also called if Instance ID has been reset in which
+ *  case, tokens and FCM topic subscriptions also need to be refreshed.
+ *
+ *  Instance ID service will throttle the refresh event across all devices
+ *  to control the rate of token updates on application servers.
+ */
+FOUNDATION_EXPORT NSString * __nonnull const kFIRInstanceIDTokenRefreshNotification;
+
+/**
+ *  @related FIRInstanceID
+ *
+ *  The completion handler invoked when the InstanceID token returns. If
+ *  the call fails we return the appropriate `error code` as described below.
+ *
+ *  @param token The valid token as returned by InstanceID backend.
+ *
+ *  @param error The error describing why generating a new token
+ *               failed. See the error codes below for a more detailed
+ *               description.
+ */
+typedef void(^FIRInstanceIDTokenHandler)(NSString * __nullable token, NSError * __nullable error);
+
+
+/**
+ *  @related FIRInstanceID
+ *
+ *  The completion handler invoked when the InstanceID `deleteToken` returns. If
+ *  the call fails we return the appropriate `error code` as described below
+ *
+ *  @param error The error describing why deleting the token failed.
+ *               See the error codes below for a more detailed description.
+ */
+typedef void(^FIRInstanceIDDeleteTokenHandler)(NSError * __nullable error);
+
+/**
+ *  @related FIRInstanceID
+ *
+ *  The completion handler invoked when the app identity is created. If the
+ *  identity wasn't created for some reason we return the appropriate error code.
+ *
+ *  @param identity A valid identity for the app instance, nil if there was an error
+ *                  while creating an identity.
+ *  @param error    The error if fetching the identity fails else nil.
+ */
+typedef void(^FIRInstanceIDHandler)(NSString * __nullable identity, NSError * __nullable error);
+
+/**
+ *  @related FIRInstanceID
+ *
+ *  The completion handler invoked when the app identity and all the tokens associated
+ *  with it are deleted. Returns a valid error object in case of failure else nil.
+ *
+ *  @param error The error if deleting the identity and all the tokens associated with
+ *               it fails else nil.
+ */
+typedef void(^FIRInstanceIDDeleteHandler)(NSError * __nullable error);
+
+/**
+ * @enum FIRInstanceIDError
+ */
+typedef NS_ENUM(NSUInteger, FIRInstanceIDError) {
+  /// Unknown error.
+  FIRInstanceIDErrorUnknown = 0,
+
+  /// Auth Error -- FCM couldn't validate request from this client.
+  FIRInstanceIDErrorAuthentication = 1,
+
+  /// NoAccess -- InstanceID service cannot be accessed.
+  FIRInstanceIDErrorNoAccess = 2,
+
+  /// Timeout -- Request to InstanceID backend timed out.
+  FIRInstanceIDErrorTimeout = 3,
+
+  /// Network -- No network available to reach the servers.
+  FIRInstanceIDErrorNetwork = 4,
+
+  /// OperationInProgress -- Another similar operation in progress,
+  /// bailing this one.
+  FIRInstanceIDErrorOperationInProgress = 5,
+
+  /// InvalidRequest -- Some parameters of the request were invalid.
+  FIRInstanceIDErrorInvalidRequest = 7,
+};
+
+/**
+ *  The APNS token type for the app. If the token type is set to `UNKNOWN`
+ *  InstanceID will implicitly try to figure out what the actual token type
+ *  is from the provisioning profile.
+ */
+typedef NS_ENUM(NSInteger, FIRInstanceIDAPNSTokenType) {
+  /// Unknown token type.
+  FIRInstanceIDAPNSTokenTypeUnknown,
+  /// Sandbox token type.
+  FIRInstanceIDAPNSTokenTypeSandbox,
+  /// Production token type.
+  FIRInstanceIDAPNSTokenTypeProd,
+};
+
+/**
+ *  Instance ID provides a unique identifier for each app instance and a mechanism
+ *  to authenticate and authorize actions (for example, sending a GCM message).
+ *
+ *  Instance ID is long lived but, may be reset if the device is not used for
+ *  a long time or the Instance ID service detects a problem.
+ *  If Instance ID is reset, the app will be notified with a `com.firebase.iid.token-refresh`
+ *  notification.
+ *
+ *  If the Instance ID has become invalid, the app can request a new one and
+ *  send it to the app server.
+ *  To prove ownership of Instance ID and to allow servers to access data or
+ *  services associated with the app, call
+ *  `[FIRInstanceID tokenWithAuthorizedEntity:scope:options:handler]`.
+ */
+@interface FIRInstanceID : NSObject
+
+/**
+ *  FIRInstanceID.
+ *
+ *  @return A shared instance of FIRInstanceID.
+ */
++ (nonnull instancetype)instanceID;
+
+/**
+ *  Set APNS token for the application. This APNS token will be used to register
+ *  with Firebase Messaging using `token` or
+ *  `tokenWithAuthorizedEntity:scope:options:handler`. If the token type is set to
+ *  `FIRInstanceIDAPNSTokenTypeUnknown` InstanceID will read the provisioning profile
+ *  to find out the token type.
+ *
+ *  @param token The APNS token for the application.
+ *  @param type  The APNS token type for the above token.
+ */
+- (void)setAPNSToken:(nonnull NSData *)token type:(FIRInstanceIDAPNSTokenType)type;
+
+#pragma mark - Tokens
+
+/**
+ *  Returns a Firebase Messaging scoped token for the firebase app.
+ *
+ *  @return Null Returns null if the device has not yet been registerd with
+ *          Firebase Message else returns a valid token.
+ */
+- (nullable NSString *)token;
+
+/**
+ *  Returns a token that authorizes an Entity (example: cloud service) to perform
+ *  an action on behalf of the application identified by Instance ID.
+ *
+ *  This is similar to an OAuth2 token except, it applies to the
+ *  application instance instead of a user.
+ *
+ *  This is an asynchronous call. If the token fetching fails for some reason
+ *  we invoke the completion callback with nil `token` and the appropriate
+ *  error.
+ *
+ *  Note, you can only have one `token` or `deleteToken` call for a given
+ *  authorizedEntity and scope at any point of time. Making another such call with the
+ *  same authorizedEntity and scope before the last one finishes will result in an
+ *  error with code `OperationInProgress`.
+ *
+ *  @see FIRInstanceID deleteTokenWithAuthorizedEntity:scope:handler:
+ *
+ *  @param authorizedEntity Entity authorized by the token.
+ *  @param scope            Action authorized for authorizedEntity.
+ *  @param options          The extra options to be sent with your token request. The
+ *                          value for the `apns_token` should be the NSData object
+ *                          passed to UIApplication's
+ *                          `didRegisterForRemoteNotificationsWithDeviceToken` method.
+ *                          All other keys and values in the options dict need to be
+ *                          instances of NSString or else they will be discarded. Bundle
+ *                          keys starting with 'GCM.' and 'GOOGLE.' are reserved.
+ *  @param handler          The callback handler which is invoked when the token is
+ *                          successfully fetched. In case of success a valid `token` and
+ *                          `nil` error are returned. In case of any error the `token`
+ *                          is nil and a valid `error` is returned. The valid error
+ *                          codes have been documented above.
+ */
+- (void)tokenWithAuthorizedEntity:(nonnull NSString *)authorizedEntity
+                            scope:(nonnull NSString *)scope
+                          options:(nonnull NSDictionary *)options
+                          handler:(nonnull FIRInstanceIDTokenHandler)handler;
+
+/**
+ *  Revokes access to a scope (action) for an entity previously
+ *  authorized by `[FIRInstanceID tokenWithAuthorizedEntity:scope:options:handler]`.
+ *
+ *  This is an asynchronous call. Call this on the main thread since InstanceID lib
+ *  is not thread safe. In case token deletion fails for some reason we invoke the
+ *  `handler` callback passed in with the appropriate error code.
+ *
+ *  Note, you can only have one `token` or `deleteToken` call for a given
+ *  authorizedEntity and scope at a point of time. Making another such call with the
+ *  same authorizedEntity and scope before the last one finishes will result in an error
+ *  with code `OperationInProgress`.
+ *
+ *  @param authorizedEntity Entity that must no longer have access.
+ *  @param scope            Action that entity is no longer authorized to perform.
+ *  @param handler          The handler that is invoked once the unsubscribe call ends.
+ *                          In case of error an appropriate error object is returned
+ *                          else error is nil.
+ */
+- (void)deleteTokenWithAuthorizedEntity:(nonnull NSString *)authorizedEntity
+                                  scope:(nonnull NSString *)scope
+                                handler:(nonnull FIRInstanceIDDeleteTokenHandler)handler;
+
+#pragma mark - Identity
+
+/**
+ *  Asynchronously fetch a stable identifier that uniquely identifies the app
+ *  instance. If the identifier has been revoked or has expired, this method will
+ *  return a new identifier.
+ *
+ *
+ *  @param handler The handler to invoke once the identifier has been fetched.
+ *                 In case of error an appropriate error object is returned else
+ *                 a valid identifier is returned and a valid identifier for the
+ *                 application instance.
+ */
+- (void)getIDWithHandler:(nonnull FIRInstanceIDHandler)handler;
+
+/**
+ *  Resets Instance ID and revokes all tokens.
+ */
+- (void)deleteIDWithHandler:(nonnull FIRInstanceIDDeleteHandler)handler;
+
+@end

Code Burner/Pods/GTMSessionFetcher/LICENSE

@@ -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.

Code Burner/Pods/GTMSessionFetcher/README.md

@@ -0,0 +1,23 @@
+# Google Toolbox for Mac - Session Fetcher #
+
+**Project site** <https://github.com/google/gtm-session-fetcher><br>
+**Discussion group** <http://groups.google.com/group/google-toolbox-for-mac>
+
+[![Build Status](https://travis-ci.org/google/gtm-session-fetcher.svg?branch=master)](https://travis-ci.org/google/gtm-session-fetcher)
+
+`GTMSessionFetcher` makes it easy for Cocoa applications to perform http
+operations. The fetcher is implemented as a wrapper on `NSURLSession`, so its
+behavior is asynchronous and uses operating-system settings on iOS and Mac OS X.
+
+Features include:
+- Simple to build; only one source/header file pair is required
+- Simple to use: takes just two lines of code to fetch a request
+- Supports upload and download sessions
+- Flexible cookie storage
+- Automatic retry on errors, with exponential backoff
+- Support for generating multipart MIME upload streams
+- Easy, convenient logging of http requests and responses
+- Supports plug-in authentication such as with gtm-oauth2
+- Easily testable; self-mocking
+- Automatic rate limiting when created by the `GTMSessionFetcherService` factory class
+- Fully independent of other projects

Code Burner/Pods/GTMSessionFetcher/Source/GTMSessionFetcherLogging.h

@@ -0,0 +1,107 @@
+/* Copyright 2014 Google Inc. All rights reserved.
+ *
+ * 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.
+ */
+
+#import "GTMSessionFetcher.h"
+
+// GTM HTTP Logging
+//
+// All traffic using GTMSessionFetcher can be easily logged.  Call
+//
+//   [GTMSessionFetcher setLoggingEnabled:YES];
+//
+// to begin generating log files.
+//
+// Log files are put into a folder on the desktop called "GTMHTTPDebugLogs"
+// unless another directory is specified with +setLoggingDirectory.
+//
+// In the iPhone simulator, the default logs location is the user's home
+// directory in ~/Library/Application Support.  On the iPhone device, the
+// default logs location is the application's documents directory on the device.
+//
+// Tip: use the Finder's "Sort By Date" to find the most recent logs.
+//
+// Each run of an application gets a separate set of log files.  An html
+// file is generated to simplify browsing the run's http transactions.
+// The html file includes javascript links for inline viewing of uploaded
+// and downloaded data.
+//
+// A symlink is created in the logs folder to simplify finding the html file
+// for the latest run of the application; the symlink is called
+//
+//   AppName_http_log_newest.html
+//
+// For better viewing of XML logs, use Camino or Firefox rather than Safari.
+//
+// Each fetcher may be given a comment to be inserted as a label in the logs,
+// such as
+//   [fetcher setCommentWithFormat:@"retrieve item %@", itemName];
+//
+// Projects may define STRIP_GTM_FETCH_LOGGING to remove logging code.
+
+#if !STRIP_GTM_FETCH_LOGGING
+
+@interface GTMSessionFetcher (GTMSessionFetcherLogging)
+
+// Note: the default logs directory is ~/Desktop/GTMHTTPDebugLogs; it will be
+// created as needed.  If a custom directory is set, the directory should
+// already exist.
++ (void)setLoggingDirectory:(NSString *)path;
++ (NSString *)loggingDirectory;
+
+// client apps can turn logging on and off
++ (void)setLoggingEnabled:(BOOL)isLoggingEnabled;
++ (BOOL)isLoggingEnabled;
+
+// client apps can turn off logging to a file if they want to only check
+// the fetcher's log property
++ (void)setLoggingToFileEnabled:(BOOL)isLoggingToFileEnabled;
++ (BOOL)isLoggingToFileEnabled;
+
+// client apps can optionally specify process name and date string used in
+// log file names
++ (void)setLoggingProcessName:(NSString *)processName;
++ (NSString *)loggingProcessName;
+
++ (void)setLoggingDateStamp:(NSString *)dateStamp;
++ (NSString *)loggingDateStamp;
+
+// client apps can specify the directory for the log for this specific run,
+// typically to match the directory used by another fetcher class, like:
+//
+//   [GTMSessionFetcher setLogDirectoryForCurrentRun:[GTMHTTPFetcher logDirectoryForCurrentRun]];
+//
+// Setting this overrides the logging directory, process name, and date stamp when writing
+// the log file.
++ (void)setLogDirectoryForCurrentRun:(NSString *)logDirectoryForCurrentRun;
++ (NSString *)logDirectoryForCurrentRun;
+
+// Prunes old log directories that have not been modified since the provided date.
+// This will not delete the current run's log directory.
++ (void)deleteLogDirectoriesOlderThanDate:(NSDate *)date;
+
+// internal; called by fetcher
+- (void)logFetchWithError:(NSError *)error;
+- (NSInputStream *)loggedInputStreamForInputStream:(NSInputStream *)inputStream;
+- (GTMSessionFetcherBodyStreamProvider)loggedStreamProviderForStreamProvider:
+    (GTMSessionFetcherBodyStreamProvider)streamProvider;
+
+// internal; accessors useful for viewing logs
++ (NSString *)processNameLogPrefix;
++ (NSString *)symlinkNameSuffix;
++ (NSString *)htmlFileName;
+
+@end
+
+#endif  // !STRIP_GTM_FETCH_LOGGING

Code Burner/Pods/GTMSessionFetcher/Source/GTMSessionFetcherLogging.m

@@ -0,0 +1,976 @@
+/* Copyright 2014 Google Inc. All rights reserved.
+ *
+ * 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.
+ */
+
+#if !defined(__has_feature) || !__has_feature(objc_arc)
+#error "This file requires ARC support."
+#endif
+
+#include <sys/stat.h>
+#include <unistd.h>
+
+#import "GTMSessionFetcherLogging.h"
+
+#ifndef STRIP_GTM_FETCH_LOGGING
+  #error GTMSessionFetcher headers should have defaulted this if it wasn't already defined.
+#endif
+
+#if !STRIP_GTM_FETCH_LOGGING
+
+// Sensitive credential strings are replaced in logs with _snip_
+//
+// Apps that must see the contents of sensitive tokens can set this to 1
+#ifndef SKIP_GTM_FETCH_LOGGING_SNIPPING
+#define SKIP_GTM_FETCH_LOGGING_SNIPPING 0
+#endif
+
+// If GTMReadMonitorInputStream is available, it can be used for
+// capturing uploaded streams of data
+//
+// We locally declare methods of GTMReadMonitorInputStream so we
+// do not need to import the header, as some projects may not have it available
+#if !GTMSESSION_BUILD_COMBINED_SOURCES
+@interface GTMReadMonitorInputStream : NSInputStream
+
++ (instancetype)inputStreamWithStream:(NSInputStream *)input;
+
+@property (assign) id readDelegate;
+@property (assign) SEL readSelector;
+
+@end
+#else
+@class GTMReadMonitorInputStream;
+#endif  // !GTMSESSION_BUILD_COMBINED_SOURCES
+
+@interface GTMSessionFetcher (GTMHTTPFetcherLoggingUtilities)
+
++ (NSString *)headersStringForDictionary:(NSDictionary *)dict;
++ (NSString *)snipSubstringOfString:(NSString *)originalStr
+                 betweenStartString:(NSString *)startStr
+                          endString:(NSString *)endStr;
+- (void)inputStream:(GTMReadMonitorInputStream *)stream
+     readIntoBuffer:(void *)buffer
+             length:(int64_t)length;
+
+@end
+
+@implementation GTMSessionFetcher (GTMSessionFetcherLogging)
+
+// fetchers come and fetchers go, but statics are forever
+static BOOL gIsLoggingEnabled = NO;
+static BOOL gIsLoggingToFile = YES;
+static NSString *gLoggingDirectoryPath = nil;
+static NSString *gLogDirectoryForCurrentRun = nil;
+static NSString *gLoggingDateStamp = nil;
+static NSString *gLoggingProcessName = nil;
+
++ (void)setLoggingDirectory:(NSString *)path {
+  gLoggingDirectoryPath = [path copy];
+}
+
++ (NSString *)loggingDirectory {
+  if (!gLoggingDirectoryPath) {
+    NSArray *paths = nil;
+#if TARGET_IPHONE_SIMULATOR
+    // default to a directory called GTMHTTPDebugLogs into a sandbox-safe
+    // directory that a developer can find easily, the application home
+    paths = @[ NSHomeDirectory() ];
+#elif TARGET_OS_IPHONE
+    // Neither ~/Desktop nor ~/Home is writable on an actual iPhone device.
+    // Put it in ~/Documents.
+    paths = NSSearchPathForDirectoriesInDomains(NSDocumentDirectory, NSUserDomainMask, YES);
+#else
+    // default to a directory called GTMHTTPDebugLogs in the desktop folder
+    paths = NSSearchPathForDirectoriesInDomains(NSDesktopDirectory, NSUserDomainMask, YES);
+#endif
+
+    NSString *desktopPath = paths.firstObject;
+    if (desktopPath) {
+      NSString *const kGTMLogFolderName = @"GTMHTTPDebugLogs";
+      NSString *logsFolderPath = [desktopPath stringByAppendingPathComponent:kGTMLogFolderName];
+
+      NSFileManager *fileMgr = [NSFileManager defaultManager];
+      BOOL isDir;
+      BOOL doesFolderExist = [fileMgr fileExistsAtPath:logsFolderPath isDirectory:&isDir];
+      if (!doesFolderExist) {
+        // make the directory
+        doesFolderExist = [fileMgr createDirectoryAtPath:logsFolderPath
+                             withIntermediateDirectories:YES
+                                              attributes:nil
+                                                   error:NULL];
+      }
+      if (doesFolderExist) {
+        // it's there; store it in the global
+        gLoggingDirectoryPath = [logsFolderPath copy];
+      }
+    }
+  }
+  return gLoggingDirectoryPath;
+}
+
++ (void)setLogDirectoryForCurrentRun:(NSString *)logDirectoryForCurrentRun {
+  // Set the path for this run's logs.
+  gLogDirectoryForCurrentRun = [logDirectoryForCurrentRun copy];
+}
+
++ (NSString *)logDirectoryForCurrentRun {
+  // make a directory for this run's logs, like SyncProto_logs_10-16_01-56-58PM
+  if (gLogDirectoryForCurrentRun) return gLogDirectoryForCurrentRun;
+
+  NSString *parentDir = [self loggingDirectory];
+  NSString *logNamePrefix = [self processNameLogPrefix];
+  NSString *dateStamp = [self loggingDateStamp];
+  NSString *dirName = [NSString stringWithFormat:@"%@%@", logNamePrefix, dateStamp];
+  NSString *logDirectory = [parentDir stringByAppendingPathComponent:dirName];
+
+  if (gIsLoggingToFile) {
+    NSFileManager *fileMgr = [NSFileManager defaultManager];
+    // Be sure that the first time this app runs, it's not writing to a preexisting folder
+    static BOOL gShouldReuseFolder = NO;
+    if (!gShouldReuseFolder) {
+      gShouldReuseFolder = YES;
+      NSString *origLogDir = logDirectory;
+      for (int ctr = 2; ctr < 20; ++ctr) {
+        if (![fileMgr fileExistsAtPath:logDirectory]) break;
+
+        // append a digit
+        logDirectory = [origLogDir stringByAppendingFormat:@"_%d", ctr];
+      }
+    }
+    if (![fileMgr createDirectoryAtPath:logDirectory
+            withIntermediateDirectories:YES
+                             attributes:nil
+                                  error:NULL]) return nil;
+  }
+  gLogDirectoryForCurrentRun = logDirectory;
+
+  return gLogDirectoryForCurrentRun;
+}
+
++ (void)setLoggingEnabled:(BOOL)isLoggingEnabled {
+  gIsLoggingEnabled = isLoggingEnabled;
+}
+
++ (BOOL)isLoggingEnabled {
+  return gIsLoggingEnabled;
+}
+
++ (void)setLoggingToFileEnabled:(BOOL)isLoggingToFileEnabled {
+  gIsLoggingToFile = isLoggingToFileEnabled;
+}
+
++ (BOOL)isLoggingToFileEnabled {
+  return gIsLoggingToFile;
+}
+
++ (void)setLoggingProcessName:(NSString *)processName {
+  gLoggingProcessName = [processName copy];
+}
+
++ (NSString *)loggingProcessName {
+  // get the process name (once per run) replacing spaces with underscores
+  if (!gLoggingProcessName) {
+    NSString *procName = [[NSProcessInfo processInfo] processName];
+    gLoggingProcessName = [procName stringByReplacingOccurrencesOfString:@" " withString:@"_"];
+  }
+  return gLoggingProcessName;
+}
+
++ (void)setLoggingDateStamp:(NSString *)dateStamp {
+  gLoggingDateStamp = [dateStamp copy];
+}
+
++ (NSString *)loggingDateStamp {
+  // We'll pick one date stamp per run, so a run that starts at a later second
+  // will get a unique results html file
+  if (!gLoggingDateStamp) {
+    // produce a string like 08-21_01-41-23PM
+
+    NSDateFormatter *formatter = [[NSDateFormatter alloc] init];
+    [formatter setFormatterBehavior:NSDateFormatterBehavior10_4];
+    [formatter setDateFormat:@"M-dd_hh-mm-ssa"];
+
+    gLoggingDateStamp = [formatter stringFromDate:[NSDate date]];
+  }
+  return gLoggingDateStamp;
+}
+
++ (NSString *)processNameLogPrefix {
+  static NSString *gPrefix = nil;
+  if (!gPrefix) {
+    NSString *processName = [self loggingProcessName];
+    gPrefix = [[NSString alloc] initWithFormat:@"%@_log_", processName];
+  }
+  return gPrefix;
+}
+
++ (NSString *)symlinkNameSuffix {
+  return @"_log_newest.html";
+}
+
++ (NSString *)htmlFileName {
+  return @"aperçu_http_log.html";
+}
+
++ (void)deleteLogDirectoriesOlderThanDate:(NSDate *)cutoffDate {
+  NSFileManager *fileMgr = [NSFileManager defaultManager];
+  NSURL *parentDir = [NSURL fileURLWithPath:[[self class] loggingDirectory]];
+  NSURL *logDirectoryForCurrentRun =
+      [NSURL fileURLWithPath:[[self class] logDirectoryForCurrentRun]];
+  NSError *error;
+  NSArray *contents = [fileMgr contentsOfDirectoryAtURL:parentDir
+                             includingPropertiesForKeys:@[ NSURLContentModificationDateKey ]
+                                                options:0
+                                                  error:&error];
+  for (NSURL *itemURL in contents) {
+    if ([itemURL isEqual:logDirectoryForCurrentRun]) continue;
+
+    NSDate *modDate;
+    if ([itemURL getResourceValue:&modDate
+                           forKey:NSURLContentModificationDateKey
+                            error:&error]) {
+      if ([modDate compare:cutoffDate] == NSOrderedAscending) {
+        if (![fileMgr removeItemAtURL:itemURL error:&error]) {
+          NSLog(@"deleteLogDirectoriesOlderThanDate failed to delete %@: %@",
+                itemURL.path, error);
+        }
+      }
+    } else {
+      NSLog(@"deleteLogDirectoriesOlderThanDate failed to get mod date of %@: %@",
+            itemURL.path, error);
+    }
+  }
+}
+
+// formattedStringFromData returns a prettyprinted string for XML or JSON input,
+// and a plain string for other input data
+- (NSString *)formattedStringFromData:(NSData *)inputData
+                          contentType:(NSString *)contentType
+                                 JSON:(NSDictionary **)outJSON {
+  if (!inputData) return nil;
+
+  // if the content type is JSON and we have the parsing class available, use that
+  if ([contentType hasPrefix:@"application/json"] && inputData.length > 5) {
+    // convert from JSON string to NSObjects and back to a formatted string
+    NSMutableDictionary *obj = [NSJSONSerialization JSONObjectWithData:inputData
+                                                               options:NSJSONReadingMutableContainers
+                                                                 error:NULL];
+    if (obj) {
+      if (outJSON) *outJSON = obj;
+      if ([obj isKindOfClass:[NSMutableDictionary class]]) {
+        // for security and privacy, omit OAuth 2 response access and refresh tokens
+        if ([obj valueForKey:@"refresh_token"] != nil) {
+          [obj setObject:@"_snip_" forKey:@"refresh_token"];
+        }
+        if ([obj valueForKey:@"access_token"] != nil) {
+          [obj setObject:@"_snip_" forKey:@"access_token"];
+        }
+      }
+      NSData *data = [NSJSONSerialization dataWithJSONObject:obj
+                                                     options:NSJSONWritingPrettyPrinted
+                                                       error:NULL];
+      if (data) {
+        NSString *jsonStr = [[NSString alloc] initWithData:data
+                                                  encoding:NSUTF8StringEncoding];
+        return jsonStr;
+      }
+    }
+  }
+
+#if !TARGET_OS_IPHONE && !GTM_SKIP_LOG_XMLFORMAT
+  // verify that this data starts with the bytes indicating XML
+
+  NSString *const kXMLLintPath = @"/usr/bin/xmllint";
+  static BOOL gHasCheckedAvailability = NO;
+  static BOOL gIsXMLLintAvailable = NO;
+
+  if (!gHasCheckedAvailability) {
+    gIsXMLLintAvailable = [[NSFileManager defaultManager] fileExistsAtPath:kXMLLintPath];
+    gHasCheckedAvailability = YES;
+  }
+  if (gIsXMLLintAvailable
+      && inputData.length > 5
+      && strncmp(inputData.bytes, "<?xml", 5) == 0) {
+
+    // call xmllint to format the data
+    NSTask *task = [[NSTask alloc] init];
+    [task setLaunchPath:kXMLLintPath];
+
+    // use the dash argument to specify stdin as the source file
+    [task setArguments:@[ @"--format", @"-" ]];
+    [task setEnvironment:@{}];
+
+    NSPipe *inputPipe = [NSPipe pipe];
+    NSPipe *outputPipe = [NSPipe pipe];
+    [task setStandardInput:inputPipe];
+    [task setStandardOutput:outputPipe];
+
+    [task launch];
+
+    [[inputPipe fileHandleForWriting] writeData:inputData];
+    [[inputPipe fileHandleForWriting] closeFile];
+
+    // drain the stdout before waiting for the task to exit
+    NSData *formattedData = [[outputPipe fileHandleForReading] readDataToEndOfFile];
+
+    [task waitUntilExit];
+
+    int status = [task terminationStatus];
+    if (status == 0 && formattedData.length > 0) {
+      // success
+      inputData = formattedData;
+    }
+  }
+#else
+  // we can't call external tasks on the iPhone; leave the XML unformatted
+#endif
+
+  NSString *dataStr = [[NSString alloc] initWithData:inputData
+                                            encoding:NSUTF8StringEncoding];
+  return dataStr;
+}
+
+// stringFromStreamData creates a string given the supplied data
+//
+// If NSString can create a UTF-8 string from the data, then that is returned.
+//
+// Otherwise, this routine tries to find a MIME boundary at the beginning of the data block, and
+// uses that to break up the data into parts. Each part will be used to try to make a UTF-8 string.
+// For parts that fail, a replacement string showing the part header and <<n bytes>> is supplied
+// in place of the binary data.
+
+- (NSString *)stringFromStreamData:(NSData *)data
+                       contentType:(NSString *)contentType {
+
+  if (!data) return nil;
+
+  // optimistically, see if the whole data block is UTF-8
+  NSString *streamDataStr = [self formattedStringFromData:data
+                                              contentType:contentType
+                                                     JSON:NULL];
+  if (streamDataStr) return streamDataStr;
+
+  // Munge a buffer by replacing non-ASCII bytes with underscores, and turn that munged buffer an
+  // NSString.  That gives us a string we can use with NSScanner.
+  NSMutableData *mutableData = [NSMutableData dataWithData:data];
+  unsigned char *bytes = (unsigned char *)mutableData.mutableBytes;
+
+  for (unsigned int idx = 0; idx < mutableData.length; ++idx) {
+    if (bytes[idx] > 0x7F || bytes[idx] == 0) {
+      bytes[idx] = '_';
+    }
+  }
+
+  NSString *mungedStr = [[NSString alloc] initWithData:mutableData
+                                              encoding:NSUTF8StringEncoding];
+  if (mungedStr) {
+
+    // scan for the boundary string
+    NSString *boundary = nil;
+    NSScanner *scanner = [NSScanner scannerWithString:mungedStr];
+
+    if ([scanner scanUpToString:@"\r\n" intoString:&boundary]
+        && [boundary hasPrefix:@"--"]) {
+
+      // we found a boundary string; use it to divide the string into parts
+      NSArray *mungedParts = [mungedStr componentsSeparatedByString:boundary];
+
+      // look at each munged part in the original string, and try to convert those into UTF-8
+      NSMutableArray *origParts = [NSMutableArray array];
+      NSUInteger offset = 0;
+      for (NSString *mungedPart in mungedParts) {
+        NSUInteger partSize = mungedPart.length;
+        NSData *origPartData = [data subdataWithRange:NSMakeRange(offset, partSize)];
+        NSString *origPartStr = [[NSString alloc] initWithData:origPartData
+                                                      encoding:NSUTF8StringEncoding];
+        if (origPartStr) {
+          // we could make this original part into UTF-8; use the string
+          [origParts addObject:origPartStr];
+        } else {
+          // this part can't be made into UTF-8; scan the header, if we can
+          NSString *header = nil;
+          NSScanner *headerScanner = [NSScanner scannerWithString:mungedPart];
+          if (![headerScanner scanUpToString:@"\r\n\r\n" intoString:&header]) {
+            // we couldn't find a header
+            header = @"";
+          }
+          // make a part string with the header and <<n bytes>>
+          NSString *binStr = [NSString stringWithFormat:@"\r%@\r<<%lu bytes>>\r",
+                              header, (long)(partSize - header.length)];
+          [origParts addObject:binStr];
+        }
+        offset += partSize + boundary.length;
+      }
+      // rejoin the original parts
+      streamDataStr = [origParts componentsJoinedByString:boundary];
+    }
+  }
+  if (!streamDataStr) {
+    // give up; just make a string showing the uploaded bytes
+    streamDataStr = [NSString stringWithFormat:@"<<%u bytes>>", (unsigned int)data.length];
+  }
+  return streamDataStr;
+}
+
+// logFetchWithError is called following a successful or failed fetch attempt
+//
+// This method does all the work for appending to and creating log files
+
+- (void)logFetchWithError:(NSError *)error {
+  if (![[self class] isLoggingEnabled]) return;
+  NSString *logDirectory = [[self class] logDirectoryForCurrentRun];
+  if (!logDirectory) return;
+  NSString *processName = [[self class] loggingProcessName];
+
+  // TODO: add Javascript to display response data formatted in hex
+
+  // each response's NSData goes into its own xml or txt file, though all responses for this run of
+  // the app share a main html file. This counter tracks all fetch responses for this app run.
+  //
+  // we'll use a local variable since this routine may be reentered while waiting for XML formatting
+  // to be completed by an external task
+  static int gResponseCounter = 0;
+  int responseCounter = ++gResponseCounter;
+
+  NSURLResponse *response = [self response];
+  NSDictionary *responseHeaders = [self responseHeaders];
+  NSString *responseDataStr = nil;
+  NSDictionary *responseJSON = nil;
+
+  // if there's response data, decide what kind of file to put it in based on the first bytes of the
+  // file or on the mime type supplied by the server
+  NSString *responseMIMEType = [response MIMEType];
+  BOOL isResponseImage = NO;
+
+  // file name for an image data file
+  NSString *responseDataFileName = nil;
+
+  int64_t responseDataLength = self.downloadedLength;
+  if (responseDataLength > 0) {
+    NSData *downloadedData = self.downloadedData;
+    if (downloadedData == nil
+        && responseDataLength > 0
+        && responseDataLength < 20000
+        && self.destinationFileURL) {
+      // There's a download file that's not too big, so get the data to display from the downloaded
+      // file.
+      NSURL *destinationURL = self.destinationFileURL;
+      downloadedData = [NSData dataWithContentsOfURL:destinationURL];
+    }
+    NSString *responseType = [responseHeaders valueForKey:@"Content-Type"];
+    responseDataStr = [self formattedStringFromData:downloadedData
+                                        contentType:responseType
+                                               JSON:&responseJSON];
+    NSString *responseDataExtn = nil;
+    NSData *dataToWrite = nil;
+    if (responseDataStr) {
+      // we were able to make a UTF-8 string from the response data
+      if ([responseMIMEType isEqual:@"application/atom+xml"]
+          || [responseMIMEType hasSuffix:@"/xml"]) {
+        responseDataExtn = @"xml";
+        dataToWrite = [responseDataStr dataUsingEncoding:NSUTF8StringEncoding];
+      }
+    } else if ([responseMIMEType isEqual:@"image/jpeg"]) {
+      responseDataExtn = @"jpg";
+      dataToWrite = downloadedData;
+      isResponseImage = YES;
+    } else if ([responseMIMEType isEqual:@"image/gif"]) {
+      responseDataExtn = @"gif";
+      dataToWrite = downloadedData;
+      isResponseImage = YES;
+    } else if ([responseMIMEType isEqual:@"image/png"]) {
+      responseDataExtn = @"png";
+      dataToWrite = downloadedData;
+      isResponseImage = YES;
+    } else {
+      // add more non-text types here
+    }
+    // if we have an extension, save the raw data in a file with that extension
+    if (responseDataExtn && dataToWrite) {
+      // generate a response file base name like
+      NSString *responseBaseName = [NSString stringWithFormat:@"fetch_%d_response", responseCounter];
+      responseDataFileName = [responseBaseName stringByAppendingPathExtension:responseDataExtn];
+      NSString *responseDataFilePath = [logDirectory stringByAppendingPathComponent:responseDataFileName];
+
+      NSError *downloadedError = nil;
+      if (gIsLoggingToFile && ![dataToWrite writeToFile:responseDataFilePath
+                                                options:0
+                                                  error:&downloadedError]) {
+        NSLog(@"%@ logging write error:%@ (%@)", [self class], downloadedError, responseDataFileName);
+      }
+    }
+  }
+  // we'll have one main html file per run of the app
+  NSString *htmlName = [[self class] htmlFileName];
+  NSString *htmlPath =[logDirectory stringByAppendingPathComponent:htmlName];
+
+  // if the html file exists (from logging previous fetches) we don't need
+  // to re-write the header or the scripts
+  NSFileManager *fileMgr = [NSFileManager defaultManager];
+  BOOL didFileExist = [fileMgr fileExistsAtPath:htmlPath];
+
+  NSMutableString* outputHTML = [NSMutableString string];
+
+  // we need a header to say we'll have UTF-8 text
+  if (!didFileExist) {
+    [outputHTML appendFormat:@"<html><head><meta http-equiv=\"content-type\" "
+        "content=\"text/html; charset=UTF-8\"><title>%@ HTTP fetch log %@</title>",
+        processName, [[self class] loggingDateStamp]];
+  }
+  // now write the visible html elements
+  NSString *copyableFileName = [NSString stringWithFormat:@"fetch_%d.txt", responseCounter];
+
+  NSDate *now = [NSDate date];
+  // write the date & time, the comment, and the link to the plain-text (copyable) log
+  [outputHTML appendFormat:@"<b>%@ &nbsp;&nbsp;&nbsp;&nbsp; ", now];
+
+  NSString *comment = [self comment];
+  if (comment.length > 0) {
+    [outputHTML appendFormat:@"%@ &nbsp;&nbsp;&nbsp;&nbsp; ", comment];
+  }
+  [outputHTML appendFormat:@"</b><a href='%@'><i>request/response log</i></a><br>", copyableFileName];
+  NSTimeInterval elapsed = -self.initialBeginFetchDate.timeIntervalSinceNow;
+  [outputHTML appendFormat:@"elapsed: %5.3fsec<br>", elapsed];
+
+  // write the request URL
+  NSURLRequest *request = self.request;
+  NSString *requestMethod = request.HTTPMethod;
+  NSURL *requestURL = request.URL;
+
+  // Save the request URL for next time in case this redirects.
+  NSString *redirectedFromURLString = [self.redirectedFromURL absoluteString];
+  self.redirectedFromURL = [requestURL copy];
+  if (redirectedFromURLString) {
+    [outputHTML appendFormat:@"<FONT COLOR='#990066'><i>redirected from %@</i></FONT><br>",
+                              redirectedFromURLString];
+  }
+  [outputHTML appendFormat:@"<b>request:</b> %@ <code>%@</code><br>\n", requestMethod, requestURL];
+
+  // write the request headers
+  NSDictionary *requestHeaders = request.allHTTPHeaderFields;
+  NSUInteger numberOfRequestHeaders = requestHeaders.count;
+  if (numberOfRequestHeaders > 0) {
+    // Indicate if the request is authorized; warn if the request is authorized but non-SSL
+    NSString *auth = [requestHeaders objectForKey:@"Authorization"];
+    NSString *headerDetails = @"";
+    if (auth) {
+      BOOL isInsecure = [[requestURL scheme] isEqual:@"http"];
+      if (isInsecure) {
+        // 26A0 = ⚠
+        headerDetails =
+            @"&nbsp;&nbsp;&nbsp;<i>authorized, non-SSL</i><FONT COLOR='#FF00FF'> &#x26A0;</FONT> ";
+      } else {
+        headerDetails = @"&nbsp;&nbsp;&nbsp;<i>authorized</i>";
+      }
+    }
+    NSString *cookiesHdr = [requestHeaders objectForKey:@"Cookie"];
+    if (cookiesHdr) {
+      headerDetails = [headerDetails stringByAppendingString:@"&nbsp;&nbsp;&nbsp;<i>cookies</i>"];
+    }
+    NSString *matchHdr = [requestHeaders objectForKey:@"If-Match"];
+    if (matchHdr) {
+      headerDetails = [headerDetails stringByAppendingString:@"&nbsp;&nbsp;&nbsp;<i>if-match</i>"];
+    }
+    matchHdr = [requestHeaders objectForKey:@"If-None-Match"];
+    if (matchHdr) {
+      headerDetails = [headerDetails stringByAppendingString:@"&nbsp;&nbsp;&nbsp;<i>if-none-match</i>"];
+    }
+    [outputHTML appendFormat:@"&nbsp;&nbsp; headers: %d  %@<br>",
+                              (int)numberOfRequestHeaders, headerDetails];
+  } else {
+    [outputHTML appendFormat:@"&nbsp;&nbsp; headers: none<br>"];
+  }
+  // write the request post data
+  NSData *bodyData = nil;
+  NSData *loggedStreamData = self.loggedStreamData;
+  if (loggedStreamData) {
+    bodyData = loggedStreamData;
+  } else {
+    bodyData = self.bodyData;
+    if (bodyData == nil) {
+      bodyData = self.request.HTTPBody;
+    }
+  }
+  uint64_t bodyDataLength = bodyData.length;
+
+  if (bodyData.length == 0) {
+    // If the data is in a body upload file URL, read that in if it's not huge.
+    NSURL *bodyFileURL = self.bodyFileURL;
+    if (bodyFileURL) {
+      NSNumber *fileSizeNum = nil;
+      NSError *fileSizeError = nil;
+      if ([bodyFileURL getResourceValue:&fileSizeNum
+                                 forKey:NSURLFileSizeKey
+                                  error:&fileSizeError]) {
+        bodyDataLength = [fileSizeNum unsignedLongLongValue];
+        if (bodyDataLength > 0 && bodyDataLength < 50000) {
+          bodyData = [NSData dataWithContentsOfURL:bodyFileURL
+                                           options:NSDataReadingUncached
+                                             error:&fileSizeError];
+        }
+      }
+    }
+  }
+  NSString *bodyDataStr = nil;
+  NSString *postType = [requestHeaders valueForKey:@"Content-Type"];
+
+  if (bodyDataLength > 0) {
+    [outputHTML appendFormat:@"&nbsp;&nbsp; data: %llu bytes, <code>%@</code><br>\n",
+                              bodyDataLength, postType ? postType : @"(no type)"];
+    NSString *logRequestBody = self.logRequestBody;
+    if (logRequestBody) {
+      bodyDataStr = [logRequestBody copy];
+      self.logRequestBody = nil;
+    } else {
+      bodyDataStr = [self stringFromStreamData:bodyData
+                                   contentType:postType];
+      if (bodyDataStr) {
+        // remove OAuth 2 client secret and refresh token
+        bodyDataStr = [[self class] snipSubstringOfString:bodyDataStr
+                                       betweenStartString:@"client_secret="
+                                                endString:@"&"];
+        bodyDataStr = [[self class] snipSubstringOfString:bodyDataStr
+                                       betweenStartString:@"refresh_token="
+                                                endString:@"&"];
+        // remove ClientLogin password
+        bodyDataStr = [[self class] snipSubstringOfString:bodyDataStr
+                                       betweenStartString:@"&Passwd="
+                                                endString:@"&"];
+      }
+    }
+  } else {
+    // no post data
+  }
+  // write the response status, MIME type, URL
+  NSInteger status = [self statusCode];
+  if (response) {
+    NSString *statusString = @"";
+    if (status != 0) {
+      if (status == 200 || status == 201) {
+        statusString = [NSString stringWithFormat:@"%ld", (long)status];
+
+        // report any JSON-RPC error
+        if ([responseJSON isKindOfClass:[NSDictionary class]]) {
+          NSDictionary *jsonError = [responseJSON objectForKey:@"error"];
+          if ([jsonError isKindOfClass:[NSDictionary class]]) {
+            NSString *jsonCode = [[jsonError valueForKey:@"code"] description];
+            NSString *jsonMessage = [jsonError valueForKey:@"message"];
+            if (jsonCode || jsonMessage) {
+              // 2691 = ⚑
+              NSString *const jsonErrFmt =
+                  @"&nbsp;&nbsp;&nbsp;<i>JSON error:</i> <FONT COLOR='#FF00FF'>%@ %@ &nbsp;&#x2691;</FONT>";
+              statusString = [statusString stringByAppendingFormat:jsonErrFmt,
+                              jsonCode ? jsonCode : @"",
+                              jsonMessage ? jsonMessage : @""];
+            }
+          }
+        }
+      } else {
+        // purple for anything other than 200 or 201
+        NSString *flag = status >= 400 ? @"&nbsp;&#x2691;" : @""; // 2691 = ⚑
+        NSString *explanation = [NSHTTPURLResponse localizedStringForStatusCode:status];
+        NSString *const statusFormat = @"<FONT COLOR='#FF00FF'>%ld %@ %@</FONT>";
+        statusString = [NSString stringWithFormat:statusFormat, (long)status, explanation, flag];
+      }
+    }
+    // show the response URL only if it's different from the request URL
+    NSString *responseURLStr = @"";
+    NSURL *responseURL = response.URL;
+
+    if (responseURL && ![responseURL isEqual:request.URL]) {
+      NSString *const responseURLFormat =
+          @"<FONT COLOR='#FF00FF'>response URL:</FONT> <code>%@</code><br>\n";
+      responseURLStr = [NSString stringWithFormat:responseURLFormat, [responseURL absoluteString]];
+    }
+    [outputHTML appendFormat:@"<b>response:</b>&nbsp;&nbsp;status %@<br>\n%@",
+                              statusString, responseURLStr];
+    // Write the response headers
+    NSUInteger numberOfResponseHeaders = responseHeaders.count;
+    if (numberOfResponseHeaders > 0) {
+      // Indicate if the server is setting cookies
+      NSString *cookiesSet = [responseHeaders valueForKey:@"Set-Cookie"];
+      NSString *cookiesStr =
+          cookiesSet ? @"&nbsp;&nbsp;<FONT COLOR='#990066'><i>sets cookies</i></FONT>" : @"";
+      // Indicate if the server is redirecting
+      NSString *location = [responseHeaders valueForKey:@"Location"];
+      BOOL isRedirect = status >= 300 && status <= 399 && location != nil;
+      NSString *redirectsStr =
+          isRedirect ? @"&nbsp;&nbsp;<FONT COLOR='#990066'><i>redirects</i></FONT>" : @"";
+      [outputHTML appendFormat:@"&nbsp;&nbsp; headers: %d  %@ %@<br>\n",
+                                (int)numberOfResponseHeaders, cookiesStr, redirectsStr];
+    } else {
+      [outputHTML appendString:@"&nbsp;&nbsp; headers: none<br>\n"];
+    }
+  }
+  // error
+  if (error) {
+    [outputHTML appendFormat:@"<b>Error:</b> %@ <br>\n", error.description];
+  }
+  // Write the response data
+  if (responseDataFileName) {
+    if (isResponseImage) {
+      // Make a small inline image that links to the full image file
+      [outputHTML appendFormat:@"&nbsp;&nbsp; data: %lld bytes, <code>%@</code><br>",
+                                responseDataLength, responseMIMEType];
+      NSString *const fmt =
+          @"<a href=\"%@\"><img src='%@' alt='image' style='border:solid thin;max-height:32'></a>\n";
+      [outputHTML appendFormat:fmt, responseDataFileName, responseDataFileName];
+    } else {
+      // The response data was XML; link to the xml file
+      NSString *const fmt =
+          @"&nbsp;&nbsp; data: %lld bytes, <code>%@</code>&nbsp;&nbsp;&nbsp;<i><a href=\"%@\">%@</a></i>\n";
+      [outputHTML appendFormat:fmt, responseDataLength, responseMIMEType,
+                               responseDataFileName, [responseDataFileName pathExtension]];
+    }
+  } else {
+    // The response data was not an image; just show the length and MIME type
+    [outputHTML appendFormat:@"&nbsp;&nbsp; data: %lld bytes, <code>%@</code>\n",
+        responseDataLength, responseMIMEType ? responseMIMEType : @"(no response type)"];
+  }
+  // Make a single string of the request and response, suitable for copying
+  // to the clipboard and pasting into a bug report
+  NSMutableString *copyable = [NSMutableString string];
+  if (comment) {
+    [copyable appendFormat:@"%@\n\n", comment];
+  }
+  [copyable appendFormat:@"%@  elapsed: %5.3fsec\n", now, elapsed];
+  if (redirectedFromURLString) {
+    [copyable appendFormat:@"Redirected from %@\n", redirectedFromURLString];
+  }
+  [copyable appendFormat:@"Request: %@ %@\n", requestMethod, requestURL];
+  if (requestHeaders.count > 0) {
+    [copyable appendFormat:@"Request headers:\n%@\n",
+                            [[self class] headersStringForDictionary:requestHeaders]];
+  }
+  if (bodyDataLength > 0) {
+    [copyable appendFormat:@"Request body: (%llu bytes)\n", bodyDataLength];
+    if (bodyDataStr) {
+      [copyable appendFormat:@"%@\n", bodyDataStr];
+    }
+    [copyable appendString:@"\n"];
+  }
+  if (response) {
+    [copyable appendFormat:@"Response: status %d\n", (int) status];
+    [copyable appendFormat:@"Response headers:\n%@\n",
+                            [[self class] headersStringForDictionary:responseHeaders]];
+    [copyable appendFormat:@"Response body: (%lld bytes)\n", responseDataLength];
+    if (responseDataLength > 0) {
+      NSString *logResponseBody = self.logResponseBody;
+      if (logResponseBody) {
+        // The user has provided the response body text.
+        responseDataStr = [logResponseBody copy];
+        self.logResponseBody = nil;
+      }
+      if (responseDataStr != nil) {
+        [copyable appendFormat:@"%@\n", responseDataStr];
+      } else {
+        // Even though it's redundant, we'll put in text to indicate that all the bytes are binary.
+        if (self.destinationFileURL) {
+          [copyable appendFormat:@"<<%lld bytes>>  to file %@\n",
+           responseDataLength, self.destinationFileURL.path];
+        } else {
+          [copyable appendFormat:@"<<%lld bytes>>\n", responseDataLength];
+        }
+      }
+    }
+  }
+  if (error) {
+    [copyable appendFormat:@"Error: %@\n", error];
+  }
+  // Save to log property before adding the separator
+  self.log = copyable;
+
+  [copyable appendString:@"-----------------------------------------------------------\n"];
+
+  // Write the copyable version to another file (linked to at the top of the html file, above)
+  //
+  // Ideally, something to just copy this to the clipboard like
+  //   <span onCopy='window.event.clipboardData.setData(\"Text\",
+  //   \"copyable stuff\");return false;'>Copy here.</span>"
+  // would work everywhere, but it only works in Safari as of 8/2010
+  if (gIsLoggingToFile) {
+    NSString *parentDir = [[self class] loggingDirectory];
+    NSString *copyablePath = [logDirectory stringByAppendingPathComponent:copyableFileName];
+    NSError *copyableError = nil;
+    if (![copyable writeToFile:copyablePath
+                    atomically:NO
+                      encoding:NSUTF8StringEncoding
+                         error:&copyableError]) {
+      // Error writing to file
+      NSLog(@"%@ logging write error:%@ (%@)", [self class], copyableError, copyablePath);
+    }
+    [outputHTML appendString:@"<br><hr><p>"];
+
+    // Append the HTML to the main output file
+    const char* htmlBytes = outputHTML.UTF8String;
+    NSOutputStream *stream = [NSOutputStream outputStreamToFileAtPath:htmlPath
+                                                               append:YES];
+    [stream open];
+    [stream write:(const uint8_t *) htmlBytes maxLength:strlen(htmlBytes)];
+    [stream close];
+
+    // Make a symlink to the latest html
+    NSString *const symlinkNameSuffix = [[self class] symlinkNameSuffix];
+    NSString *symlinkName = [processName stringByAppendingString:symlinkNameSuffix];
+    NSString *symlinkPath = [parentDir stringByAppendingPathComponent:symlinkName];
+
+    [fileMgr removeItemAtPath:symlinkPath error:NULL];
+    [fileMgr createSymbolicLinkAtPath:symlinkPath
+                  withDestinationPath:htmlPath
+                                error:NULL];
+#if TARGET_OS_IPHONE
+    static BOOL gReportedLoggingPath = NO;
+    if (!gReportedLoggingPath) {
+      gReportedLoggingPath = YES;
+      NSLog(@"GTMSessionFetcher logging to \"%@\"", parentDir);
+    }
+#endif
+  }
+}
+
+- (NSInputStream *)loggedInputStreamForInputStream:(NSInputStream *)inputStream {
+  if (!inputStream) return nil;
+  if (![GTMSessionFetcher isLoggingEnabled]) return inputStream;
+
+  [self clearLoggedStreamData];  // Clear any previous data.
+  Class monitorClass = NSClassFromString(@"GTMReadMonitorInputStream");
+  if (!monitorClass) {
+    NSString const *str = @"<<Uploaded stream log unavailable without GTMReadMonitorInputStream>>";
+    NSData *stringData = [str dataUsingEncoding:NSUTF8StringEncoding];
+    [self appendLoggedStreamData:stringData];
+    return inputStream;
+  }
+  inputStream = [monitorClass inputStreamWithStream:inputStream];
+
+  GTMReadMonitorInputStream *readMonitorInputStream = (GTMReadMonitorInputStream *)inputStream;
+  [readMonitorInputStream setReadDelegate:self];
+  SEL readSel = @selector(inputStream:readIntoBuffer:length:);
+  [readMonitorInputStream setReadSelector:readSel];
+
+  return inputStream;
+}
+
+- (GTMSessionFetcherBodyStreamProvider)loggedStreamProviderForStreamProvider:
+    (GTMSessionFetcherBodyStreamProvider)streamProvider {
+  if (!streamProvider) return nil;
+  if (![GTMSessionFetcher isLoggingEnabled]) return streamProvider;
+
+  [self clearLoggedStreamData];  // Clear any previous data.
+  Class monitorClass = NSClassFromString(@"GTMReadMonitorInputStream");
+  if (!monitorClass) {
+    NSString const *str = @"<<Uploaded stream log unavailable without GTMReadMonitorInputStream>>";
+    NSData *stringData = [str dataUsingEncoding:NSUTF8StringEncoding];
+    [self appendLoggedStreamData:stringData];
+    return streamProvider;
+  }
+  GTMSessionFetcherBodyStreamProvider loggedStreamProvider =
+      ^(GTMSessionFetcherBodyStreamProviderResponse response) {
+      streamProvider(^(NSInputStream *bodyStream) {
+          bodyStream = [self loggedInputStreamForInputStream:bodyStream];
+          response(bodyStream);
+      });
+  };
+  return loggedStreamProvider;
+}
+
+@end
+
+@implementation GTMSessionFetcher (GTMSessionFetcherLoggingUtilities)
+
+- (void)inputStream:(GTMReadMonitorInputStream *)stream
+     readIntoBuffer:(void *)buffer
+             length:(int64_t)length {
+  // append the captured data
+  NSData *data = [NSData dataWithBytesNoCopy:buffer
+                                      length:(NSUInteger)length
+                                freeWhenDone:NO];
+  [self appendLoggedStreamData:data];
+}
+
+#pragma mark Fomatting Utilities
+
++ (NSString *)snipSubstringOfString:(NSString *)originalStr
+                 betweenStartString:(NSString *)startStr
+                          endString:(NSString *)endStr {
+#if SKIP_GTM_FETCH_LOGGING_SNIPPING
+  return originalStr;
+#else
+  if (!originalStr) return nil;
+
+  // Find the start string, and replace everything between it
+  // and the end string (or the end of the original string) with "_snip_"
+  NSRange startRange = [originalStr rangeOfString:startStr];
+  if (startRange.location == NSNotFound) return originalStr;
+
+  // We found the start string
+  NSUInteger originalLength = originalStr.length;
+  NSUInteger startOfTarget = NSMaxRange(startRange);
+  NSRange targetAndRest = NSMakeRange(startOfTarget, originalLength - startOfTarget);
+  NSRange endRange = [originalStr rangeOfString:endStr
+                                        options:0
+                                          range:targetAndRest];
+  NSRange replaceRange;
+  if (endRange.location == NSNotFound) {
+    // Found no end marker so replace to end of string
+    replaceRange = targetAndRest;
+  } else {
+    // Replace up to the endStr
+    replaceRange = NSMakeRange(startOfTarget, endRange.location - startOfTarget);
+  }
+  NSString *result = [originalStr stringByReplacingCharactersInRange:replaceRange
+                                                          withString:@"_snip_"];
+  return result;
+#endif // SKIP_GTM_FETCH_LOGGING_SNIPPING
+}
+
++ (NSString *)headersStringForDictionary:(NSDictionary *)dict {
+  // Format the dictionary in http header style, like
+  //   Accept:        application/json
+  //   Cache-Control: no-cache
+  //   Content-Type:  application/json; charset=utf-8
+  //
+  // Pad the key names, but not beyond 16 chars, since long custom header
+  // keys just create too much whitespace
+  NSArray *keys = [dict.allKeys sortedArrayUsingSelector:@selector(compare:)];
+
+  NSMutableString *str = [NSMutableString string];
+  for (NSString *key in keys) {
+    NSString *value = [dict valueForKey:key];
+    if ([key isEqual:@"Authorization"]) {
+      // Remove OAuth 1 token
+      value = [[self class] snipSubstringOfString:value
+                               betweenStartString:@"oauth_token=\""
+                                        endString:@"\""];
+
+      // Remove OAuth 2 bearer token (draft 16, and older form)
+      value = [[self class] snipSubstringOfString:value
+                               betweenStartString:@"Bearer "
+                                        endString:@"\n"];
+      value = [[self class] snipSubstringOfString:value
+                               betweenStartString:@"OAuth "
+                                        endString:@"\n"];
+
+      // Remove Google ClientLogin
+      value = [[self class] snipSubstringOfString:value
+                               betweenStartString:@"GoogleLogin auth="
+                                        endString:@"\n"];
+    }
+    [str appendFormat:@"  %@: %@\n", key, value];
+  }
+  return str;
+}
+
+@end
+
+#endif // !STRIP_GTM_FETCH_LOGGING

Code Burner/Pods/GTMSessionFetcher/Source/GTMSessionFetcherService.h

@@ -0,0 +1,190 @@
+/* Copyright 2014 Google Inc. All rights reserved.
+ *
+ * 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.
+ */
+
+// For best performance and convenient usage, fetchers should be generated by a common
+// GTMSessionFetcherService instance, like
+//
+//   _fetcherService = [[GTMSessionFetcherService alloc] init];
+//   GTMSessionFetcher* myFirstFetcher = [_fetcherService fetcherWithRequest:request1];
+//   GTMSessionFetcher* mySecondFetcher = [_fetcherService fetcherWithRequest:request2];
+
+#import "GTMSessionFetcher.h"
+
+GTM_ASSUME_NONNULL_BEGIN
+
+// Notifications.
+
+// This notification indicates a reusable session has become invalid. It is intended mainly for the
+// service's unit tests.
+//
+// The notification object is the fetcher service.
+// The invalid session is provided via the userInfo kGTMSessionFetcherServiceSessionKey key.
+extern NSString *const kGTMSessionFetcherServiceSessionBecameInvalidNotification;
+extern NSString *const kGTMSessionFetcherServiceSessionKey;
+
+@interface GTMSessionFetcherService : NSObject<GTMSessionFetcherServiceProtocol>
+
+// Queues of delayed and running fetchers. Each dictionary contains arrays
+// of GTMSessionFetcher *fetchers, keyed by NSString *host
+@property(atomic, strong, readonly, GTM_NULLABLE) GTM_NSDictionaryOf(NSString *, NSArray *) *delayedFetchersByHost;
+@property(atomic, strong, readonly, GTM_NULLABLE) GTM_NSDictionaryOf(NSString *, NSArray *) *runningFetchersByHost;
+
+// A max value of 0 means no fetchers should be delayed.
+// The default limit is 10 simultaneous fetchers targeting each host.
+// This does not apply to fetchers whose useBackgroundSession property is YES. Since services are
+// not resurrected on an app relaunch, delayed fetchers would effectively be abandoned.
+@property(atomic, assign) NSUInteger maxRunningFetchersPerHost;
+
+// Properties to be applied to each fetcher; see GTMSessionFetcher.h for descriptions
+@property(atomic, strong, GTM_NULLABLE) NSURLSessionConfiguration *configuration;
+@property(atomic, copy, GTM_NULLABLE) GTMSessionFetcherConfigurationBlock configurationBlock;
+@property(atomic, strong, GTM_NULLABLE) NSHTTPCookieStorage *cookieStorage;
+@property(atomic, strong, GTM_NULL_RESETTABLE) dispatch_queue_t callbackQueue;
+@property(atomic, copy, GTM_NULLABLE) GTMSessionFetcherChallengeBlock challengeBlock;
+@property(atomic, strong, GTM_NULLABLE) NSURLCredential *credential;
+@property(atomic, strong) NSURLCredential *proxyCredential;
+@property(atomic, copy, GTM_NULLABLE) GTM_NSArrayOf(NSString *) *allowedInsecureSchemes;
+@property(atomic, assign) BOOL allowLocalhostRequest;
+@property(atomic, assign) BOOL allowInvalidServerCertificates;
+@property(atomic, assign, getter=isRetryEnabled) BOOL retryEnabled;
+@property(atomic, copy, GTM_NULLABLE) GTMSessionFetcherRetryBlock retryBlock;
+@property(atomic, assign) NSTimeInterval maxRetryInterval;
+@property(atomic, assign) NSTimeInterval minRetryInterval;
+@property(atomic, copy, GTM_NULLABLE) GTM_NSDictionaryOf(NSString *, id) *properties;
+
+#if GTM_BACKGROUND_TASK_FETCHING
+@property(atomic, assign) BOOL skipBackgroundTask;
+#endif
+
+// A default useragent of GTMFetcherStandardUserAgentString(nil) will be given to each fetcher
+// created by this service unless the request already has a user-agent header set.
+// This default will be added starting with builds with the SDKs for OS X 10.11 and iOS 9.
+//
+// To use the configuration's default user agent, set this property to nil.
+@property(atomic, copy, GTM_NULLABLE) NSString *userAgent;
+
+// The authorizer to attach to the created fetchers. If a specific fetcher should
+// not authorize its requests, the fetcher's authorizer property may be set to nil
+// before the fetch begins.
+@property(atomic, strong, GTM_NULLABLE) id<GTMFetcherAuthorizationProtocol> authorizer;
+
+// Delegate queue used by the session when calling back to the fetcher.  The default
+// is the main queue.  Changing this does not affect the queue used to call back to the
+// application; that is specified by the callbackQueue property above.
+@property(atomic, strong, GTM_NULL_RESETTABLE) NSOperationQueue *sessionDelegateQueue;
+
+// When enabled, indicates the same session should be used by subsequent fetchers.
+//
+// This is enabled by default.
+@property(atomic, assign) BOOL reuseSession;
+
+// Sets the delay until an unused session is invalidated.
+// The default interval is 60 seconds.
+//
+// If the interval is set to 0, then any reused session is not invalidated except by
+// explicitly invoking -resetSession.  Be aware that setting the interval to 0 thus
+// causes the session's delegate to be retained until the session is explicitly reset.
+@property(atomic, assign) NSTimeInterval unusedSessionTimeout;
+
+// If shouldReuseSession is enabled, this will force creation of a new session when future
+// fetchers begin.
+- (void)resetSession;
+
+// Create a fetcher
+//
+// These methods will return a fetcher. If successfully created, the connection
+// will hold a strong reference to it for the life of the connection as well.
+// So the caller doesn't have to hold onto the fetcher explicitly unless they
+// want to be able to monitor or cancel it.
+- (GTMSessionFetcher *)fetcherWithRequest:(NSURLRequest *)request;
+- (GTMSessionFetcher *)fetcherWithURL:(NSURL *)requestURL;
+- (GTMSessionFetcher *)fetcherWithURLString:(NSString *)requestURLString;
+
+// Common method for fetcher creation.
+//
+// -fetcherWithRequest:fetcherClass: may be overridden to customize creation of
+// fetchers.  This is the ONLY method in the GTMSessionFetcher library intended to
+// be overridden.
+- (id)fetcherWithRequest:(NSURLRequest *)request
+            fetcherClass:(Class)fetcherClass;
+
+- (BOOL)isDelayingFetcher:(GTMSessionFetcher *)fetcher;
+
+- (NSUInteger)numberOfFetchers;        // running + delayed fetchers
+- (NSUInteger)numberOfRunningFetchers;
+- (NSUInteger)numberOfDelayedFetchers;
+
+// Return a list of all running or delayed fetchers. This includes fetchers created
+// by the service which have been started and have not yet stopped.
+//
+// Returns an array of fetcher objects, or nil if none.
+- (GTM_NULLABLE GTM_NSArrayOf(GTMSessionFetcher *) *)issuedFetchers;
+
+// Search for running or delayed fetchers with the specified URL.
+//
+// Returns an array of fetcher objects found, or nil if none found.
+- (GTM_NULLABLE GTM_NSArrayOf(GTMSessionFetcher *) *)issuedFetchersWithRequestURL:(NSURL *)requestURL;
+
+- (void)stopAllFetchers;
+
+// Methods for use by the fetcher class only.
+- (GTM_NULLABLE NSURLSession *)session;
+- (GTM_NULLABLE NSURLSession *)sessionForFetcherCreation;
+- (GTM_NULLABLE id<NSURLSessionDelegate>)sessionDelegate;
+- (GTM_NULLABLE NSDate *)stoppedAllFetchersDate;
+
+// The testBlock can inspect its fetcher parameter's request property to
+// determine which fetcher is being faked.
+@property(atomic, copy, GTM_NULLABLE) GTMSessionFetcherTestBlock testBlock;
+
+@end
+
+@interface GTMSessionFetcherService (TestingSupport)
+
+// Convenience method to create a fetcher service for testing.
+//
+// Fetchers generated by this mock fetcher service will not perform any
+// network operation, but will invoke callbacks and provide the supplied data
+// or error to the completion handler.
+//
+// You can make more customized mocks by setting the test block property of the service
+// or fetcher; the test block can inspect the fetcher's request or other properties.
+//
+// See the description of the testBlock property below.
++ (instancetype)mockFetcherServiceWithFakedData:(GTM_NULLABLE NSData *)fakedDataOrNil
+                                     fakedError:(GTM_NULLABLE NSError *)fakedErrorOrNil;
+
+// Spin the run loop and discard events (or, if not on the main thread, just sleep the thread)
+// until all running and delayed fetchers have completed.
+//
+// This is only for use in testing or in tools without a user interface.
+//
+// Synchronous fetches should never be done by shipping apps; they are
+// sufficient reason for rejection from the app store.
+//
+// Returns NO if timed out.
+- (BOOL)waitForCompletionOfAllFetchersWithTimeout:(NSTimeInterval)timeoutInSeconds;
+
+@end
+
+@interface GTMSessionFetcherService (BackwardsCompatibilityOnly)
+
+// Clients using GTMSessionFetcher should set the cookie storage explicitly themselves.
+// This method is just for compatibility with the old fetcher.
+@property(atomic, assign) NSInteger cookieStorageMethod;
+
+@end
+
+GTM_ASSUME_NONNULL_END

Code Burner/Pods/GTMSessionFetcher/Source/GTMSessionUploadFetcher.h

@@ -0,0 +1,128 @@
+/* Copyright 2014 Google Inc. All rights reserved.
+ *
+ * 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.
+ */
+
+// GTMSessionUploadFetcher implements Google's resumable upload protocol.
+
+//
+// This subclass of GTMSessionFetcher simulates the series of fetches
+// needed for chunked upload as a single fetch operation.
+//
+// Protocol document:  TBD
+//
+// To the client, the only fetcher that exists is this class; the subsidiary
+// fetchers needed for uploading chunks are not visible (though the most recent
+// chunk fetcher may be accessed via the -activeFetcher or -chunkFetcher methods, and
+// -responseHeaders and -statusCode reflect results from the most recent chunk
+// fetcher.)
+//
+// Chunk fetchers are discarded as soon as they have completed.
+//
+
+// Note: Unlike the fetcher superclass, the methods of GTMSessionUploadFetcher should
+// only be used from the main thread until further work is done to make this subclass
+// thread-safe.
+
+#import "GTMSessionFetcher.h"
+#import "GTMSessionFetcherService.h"
+
+GTM_ASSUME_NONNULL_BEGIN
+
+// Unless an application knows it needs a smaller chunk size, it should use the standard
+// chunk size, which sends the entire file as a single chunk to minimize upload overhead.
+extern int64_t const kGTMSessionUploadFetcherStandardChunkSize;
+
+// When uploading requires data buffer allocations (such as uploading from an NSData or
+// an NSFileHandle) this is the maximum buffer size that will be created by the fetcher.
+extern int64_t const kGTMSessionUploadFetcherMaximumDemandBufferSize;
+
+// Notification that the upload location URL was provided by the server.
+extern NSString *const kGTMSessionFetcherUploadLocationObtainedNotification;
+
+// Block to provide data during uploads.
+//
+// Response data may be allocated with dataWithBytesNoCopy:length:freeWhenDone: for efficiency,
+// and released after the response block returns.
+//
+// Pass nil as the data (and optionally an NSError) for a failure.
+typedef void (^GTMSessionUploadFetcherDataProviderResponse)(NSData * GTM_NULLABLE_TYPE data,
+                                                            NSError * GTM_NULLABLE_TYPE error);
+typedef void (^GTMSessionUploadFetcherDataProvider)(int64_t offset, int64_t length,
+    GTMSessionUploadFetcherDataProviderResponse response);
+
+@interface GTMSessionUploadFetcher : GTMSessionFetcher
+
+// Create an upload fetcher specifying either the request or the resume location URL,
+// then set an upload data source using one of these:
+//
+//   setUploadFileURL:
+//   setUploadDataLength:provider:
+//   setUploadFileHandle:
+//   setUploadData:
+
++ (instancetype)uploadFetcherWithRequest:(NSURLRequest *)request
+                          uploadMIMEType:(NSString *)uploadMIMEType
+                               chunkSize:(int64_t)chunkSize
+                          fetcherService:(GTM_NULLABLE GTMSessionFetcherService *)fetcherServiceOrNil;
+
++ (instancetype)uploadFetcherWithLocation:(NSURL * GTM_NULLABLE_TYPE)uploadLocationURL
+                           uploadMIMEType:(NSString *)uploadMIMEType
+                                chunkSize:(int64_t)chunkSize
+                           fetcherService:(GTM_NULLABLE GTMSessionFetcherService *)fetcherServiceOrNil;
+
+- (void)setUploadDataLength:(int64_t)fullLength
+                   provider:(GTM_NULLABLE GTMSessionUploadFetcherDataProvider)block;
+
++ (NSArray *)uploadFetchersForBackgroundSessions;
++ (GTM_NULLABLE instancetype)uploadFetcherForSessionIdentifier:(NSString *)sessionIdentifier;
+
+- (void)pauseFetching;
+- (void)resumeFetching;
+- (BOOL)isPaused;
+
+@property(atomic, strong, GTM_NULLABLE) NSURL *uploadLocationURL;
+@property(atomic, strong, GTM_NULLABLE) NSData *uploadData;
+@property(atomic, strong, GTM_NULLABLE) NSURL *uploadFileURL;
+@property(atomic, strong, GTM_NULLABLE) NSFileHandle *uploadFileHandle;
+@property(atomic, copy, readonly, GTM_NULLABLE) GTMSessionUploadFetcherDataProvider uploadDataProvider;
+@property(atomic, copy) NSString *uploadMIMEType;
+@property(atomic, assign) int64_t chunkSize;
+@property(atomic, readonly, assign) int64_t currentOffset;
+
+// The fetcher for the current data chunk, if any
+@property(atomic, strong, GTM_NULLABLE) GTMSessionFetcher *chunkFetcher;
+
+// The active fetcher is the current chunk fetcher, or the upload fetcher itself
+// if no chunk fetcher has yet been created.
+@property(atomic, readonly) GTMSessionFetcher *activeFetcher;
+
+// The last request made by an active fetcher.  Useful for testing.
+@property(atomic, readonly, GTM_NULLABLE) NSURLRequest *lastChunkRequest;
+
+// The status code from the most recently-completed fetch.
+@property(atomic, assign) NSInteger statusCode;
+
+// Exposed for testing only.
+@property(atomic, readonly, GTM_NULLABLE) dispatch_queue_t delegateCallbackQueue;
+@property(atomic, readonly, GTM_NULLABLE) GTMSessionFetcherCompletionHandler delegateCompletionHandler;
+
+@end
+
+@interface GTMSessionFetcher (GTMSessionUploadFetcherMethods)
+
+@property(readonly, GTM_NULLABLE) GTMSessionUploadFetcher *parentUploadFetcher;
+
+@end
+
+GTM_ASSUME_NONNULL_END

Code Burner/Pods/GoogleToolboxForMac/DebugUtils/GTMDebugSelectorValidation.h

@@ -0,0 +1,100 @@
+//
+//  GTMDebugSelectorValidation.h
+//
+//  This file should only be included within an implimation file.  In any
+//  function that takes an object and selector to invoke, you should call:
+//
+//    GTMAssertSelectorNilOrImplementedWithArguments(obj, sel, @encode(arg1type), ..., NULL)
+//  or
+//    GTMAssertSelectorNilOrImplementedWithReturnTypeAndArguments(obj, sel, @encode(returnType), @encode(arg1type), ..., NULL)
+//
+//  This will then validate that the selector is defined and using the right
+//  type(s), this can help catch errors much earlier then waiting for the
+//  selector to actually fire (and in the case of error selectors, might never
+//  really be tested until in the field).
+//
+//  Copyright 2007-2008 Google Inc.
+//
+//  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.
+//
+
+#if DEBUG
+
+#import <stdarg.h>
+#import "GTMDefines.h"
+
+static void GTMAssertSelectorNilOrImplementedWithReturnTypeAndArguments(id obj, SEL sel, const char *retType, ...) {
+
+  // verify that the object's selector is implemented with the proper
+  // number and type of arguments
+  va_list argList;
+  va_start(argList, retType);
+  
+  if (obj && sel) {
+    // check that the selector is implemented
+    _GTMDevAssert([obj respondsToSelector:sel],
+                  @"\"%@\" selector \"%@\" is unimplemented or misnamed", 
+                  NSStringFromClass([obj class]), 
+                  NSStringFromSelector(sel));
+
+    const char *expectedArgType;
+    NSUInteger argCount = 2; // skip self and _cmd
+    NSMethodSignature *sig = [obj methodSignatureForSelector:sel];
+    
+    // check that each expected argument is present and of the correct type
+    while ((expectedArgType = va_arg(argList, const char*)) != 0) {
+        
+      if ([sig numberOfArguments] > argCount) {
+        const char *foundArgType = [sig getArgumentTypeAtIndex:argCount];
+          
+        _GTMDevAssert(0 == strncmp(foundArgType, expectedArgType, strlen(expectedArgType)),
+                      @"\"%@\" selector \"%@\" argument %u should be type %s", 
+                      NSStringFromClass([obj class]), 
+                      NSStringFromSelector(sel),
+                      (uint32_t)(argCount - 2),
+                      expectedArgType);
+      }
+      argCount++;
+    }
+      
+    // check that the proper number of arguments are present in the selector
+    _GTMDevAssert(argCount == [sig numberOfArguments],
+                  @"\"%@\" selector \"%@\" should have %u arguments",
+                  NSStringFromClass([obj class]), 
+                  NSStringFromSelector(sel),
+                  (uint32_t)(argCount - 2));
+    
+    // if asked, validate the return type
+    if (retType && (strcmp("gtm_skip_return_test", retType) != 0)) {
+      const char *foundRetType = [sig methodReturnType];
+      _GTMDevAssert(0 == strncmp(foundRetType, retType, strlen(retType)),
+                    @"\"%@\" selector \"%@\" return type should be type %s", 
+                    NSStringFromClass([obj class]), 
+                    NSStringFromSelector(sel),
+                    retType);
+    }
+  }
+  
+  va_end(argList);
+}
+
+#define GTMAssertSelectorNilOrImplementedWithArguments(obj, sel, ...) \
+  GTMAssertSelectorNilOrImplementedWithReturnTypeAndArguments((obj), (sel), "gtm_skip_return_test", __VA_ARGS__)
+
+#else // DEBUG
+
+// make it go away if not debug
+#define GTMAssertSelectorNilOrImplementedWithReturnTypeAndArguments(obj, sel, retType, ...) do { } while (0)
+#define GTMAssertSelectorNilOrImplementedWithArguments(obj, sel, ...) do { } while (0)
+
+#endif // DEBUG

Code Burner/Pods/GoogleToolboxForMac/DebugUtils/GTMDebugThreadValidation.h

@@ -0,0 +1,44 @@
+//
+//  GTMDebugThreadValidation.h
+//
+//  Copyright 2016 Google Inc.
+//
+//  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.
+//
+
+#import "GTMDefines.h"
+#import <Foundation/Foundation.h>
+
+// GTMCheckCurrentQueue, GTMIsCurrentQueue
+//
+// GTMCheckCurrentQueue takes a target queue and uses _GTMDevAssert to
+// report if that is not the currently executing queue.
+//
+// GTMIsCurrentQueue takes a target queue and returns true if the target queue
+// is the currently executing dispatch queue. This can be passed to another
+// assertion call in debug builds; it should never be used in release code.
+//
+// The dispatch queue must have a label.
+#define GTMCheckCurrentQueue(targetQueue)                    \
+  _GTMDevAssert(GTMIsCurrentQueue(targetQueue),              \
+                @"Current queue is %s (expected %s)",        \
+                _GTMQueueName(DISPATCH_CURRENT_QUEUE_LABEL), \
+                _GTMQueueName(targetQueue))
+
+#define GTMIsCurrentQueue(targetQueue)                 \
+  (strcmp(_GTMQueueName(DISPATCH_CURRENT_QUEUE_LABEL), \
+          _GTMQueueName(targetQueue)) == 0)
+
+#define _GTMQueueName(queue)                     \
+  (strlen(dispatch_queue_get_label(queue)) > 0 ? \
+    dispatch_queue_get_label(queue) : "unnamed")

Code Burner/Pods/GoogleToolboxForMac/DebugUtils/GTMMethodCheck.h

@@ -0,0 +1,69 @@
+//
+//  GTMMethodCheck.h
+//
+//  Copyright 2006-2016 Google Inc.
+//
+//  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.
+//
+
+#import <Foundation/Foundation.h>
+#import <stdio.h>
+#import <sysexits.h>
+
+/// A macro for enforcing debug time checks to make sure all required methods are linked in
+//
+// When using categories, it can be very easy to forget to include the
+// implementation of a category.
+// Let's say you had a class foo that depended on method bar of class baz, and
+// method bar was implemented as a member of a category.
+// You could add the following code:
+//
+// GTM_METHOD_CHECK(baz, bar)
+//
+// and the code would check to make sure baz was implemented just before main
+// was called. This works for both dynamic libraries, and executables.
+//
+//
+// This is not compiled into release builds.
+
+#ifdef DEBUG
+
+// This is the "magic".
+// A) we need a multi layer define here so that the preprocessor expands
+//    __LINE__ the way we want it. We need __LINE__ so that each of our
+//    GTM_METHOD_CHECKs generates a unique function name.
+#define GTM_METHOD_CHECK(class, method) GTM_METHOD_CHECK_INNER(class, method, __LINE__)
+#define GTM_METHOD_CHECK_INNER(class, method, line) \
+    GTM_METHOD_CHECK_INNER_INNER(class, method, line)
+
+// B) define a function that is called at startup to check that |class| has an
+//    implementation for |method| (either a class method or an instance method).
+#define GTM_METHOD_CHECK_INNER_INNER(class, method, line) \
+__attribute__ ((constructor, visibility("hidden"))) \
+    static void xxGTMMethodCheckMethod ## class ## line () { \
+  @autoreleasepool { \
+    if (![class instancesRespondToSelector:@selector(method)] \
+        && ![class respondsToSelector:@selector(method)]) { \
+      fprintf(stderr, "%s:%d: error: We need method '%s' to be linked in for class '%s'\n", \
+              __FILE__, line, #method, #class); \
+      exit(EX_SOFTWARE); \
+    } \
+  } \
+}
+
+#else  // DEBUG
+
+// Do nothing in release.
+#define GTM_METHOD_CHECK(class, method)
+
+#endif  // DEBUG

Code Burner/Pods/GoogleToolboxForMac/Foundation/GTMNSData+zlib.h

@@ -0,0 +1,199 @@
+//
+//  GTMNSData+zlib.h
+//
+//  Copyright 2007-2008 Google Inc.
+//
+//  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.
+//
+
+#import <Foundation/Foundation.h>
+#import "GTMDefines.h"
+
+/// Helpers for dealing w/ zlib inflate/deflate calls.
+@interface NSData (GTMZLibAdditions)
+
+// NOTE: For 64bit, none of these apis handle input sizes >32bits, they will
+// return nil when given such data.  To handle data of that size you really
+// should be streaming it rather then doing it all in memory.
+
+#pragma mark Gzip Compression
+
+/// Return an autoreleased NSData w/ the result of gzipping the bytes.
+//
+//  Uses the default compression level.
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length;
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length
+                              error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of gzipping the payload of |data|.
+//
+//  Uses the default compression level.
++ (NSData *)gtm_dataByGzippingData:(NSData *)data __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByGzippingData:(NSData *)data
+                             error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of gzipping the bytes using |level| compression level.
+//
+// |level| can be 1-9, any other values will be clipped to that range.
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length
+                   compressionLevel:(int)level __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length
+                   compressionLevel:(int)level
+                              error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of gzipping the payload of |data| using |level| compression level.
++ (NSData *)gtm_dataByGzippingData:(NSData *)data
+                  compressionLevel:(int)level __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByGzippingData:(NSData *)data
+                  compressionLevel:(int)level
+                             error:(NSError **)error;
+
+#pragma mark Zlib "Stream" Compression
+
+// NOTE: deflate is *NOT* gzip.  deflate is a "zlib" stream.  pick which one
+// you really want to create.  (the inflate api will handle either)
+
+/// Return an autoreleased NSData w/ the result of deflating the bytes.
+//
+//  Uses the default compression level.
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                               error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of deflating the payload of |data|.
+//
+//  Uses the default compression level.
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data
+                              error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of deflating the bytes using |level| compression level.
+//
+// |level| can be 1-9, any other values will be clipped to that range.
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                    compressionLevel:(int)level __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                    compressionLevel:(int)level
+                               error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of deflating the payload of |data| using |level| compression level.
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data
+                   compressionLevel:(int)level __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data
+                   compressionLevel:(int)level
+                              error:(NSError **)error;
+
+#pragma mark Uncompress of Gzip or Zlib
+
+/// Return an autoreleased NSData w/ the result of decompressing the bytes.
+//
+// The bytes to decompress can be zlib or gzip payloads.
++ (NSData *)gtm_dataByInflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByInflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                               error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of decompressing the payload of |data|.
+//
+// The data to decompress can be zlib or gzip payloads.
++ (NSData *)gtm_dataByInflatingData:(NSData *)data __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByInflatingData:(NSData *)data
+                              error:(NSError **)error;
+
+#pragma mark "Raw" Compression Support
+
+// NOTE: raw deflate is *NOT* gzip or deflate.  it does not include a header
+// of any form and should only be used within streams here an external crc/etc.
+// is done to validate the data.  The RawInflate apis can be used on data
+// processed like this.
+
+/// Return an autoreleased NSData w/ the result of *raw* deflating the bytes.
+//
+//  Uses the default compression level.
+//  *No* header is added to the resulting data.
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                                  error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of *raw* deflating the payload of |data|.
+//
+//  Uses the default compression level.
+//  *No* header is added to the resulting data.
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data
+                                 error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of *raw* deflating the bytes using |level| compression level.
+//
+// |level| can be 1-9, any other values will be clipped to that range.
+//  *No* header is added to the resulting data.
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                       compressionLevel:(int)level __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                       compressionLevel:(int)level
+                                  error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of *raw* deflating the payload of |data| using |level| compression level.
+//  *No* header is added to the resulting data.
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data
+                      compressionLevel:(int)level __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data
+                      compressionLevel:(int)level
+                                 error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of *raw* decompressing the bytes.
+//
+// The data to decompress, it should *not* have any header (zlib nor gzip).
++ (NSData *)gtm_dataByRawInflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByRawInflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                                  error:(NSError **)error;
+
+/// Return an autoreleased NSData w/ the result of *raw* decompressing the payload of |data|.
+//
+// The data to decompress, it should *not* have any header (zlib nor gzip).
++ (NSData *)gtm_dataByRawInflatingData:(NSData *)data __attribute__((deprecated("Use error variant")));
++ (NSData *)gtm_dataByRawInflatingData:(NSData *)data
+                                 error:(NSError **)error;
+
+@end
+
+FOUNDATION_EXPORT NSString *const GTMNSDataZlibErrorDomain;
+FOUNDATION_EXPORT NSString *const GTMNSDataZlibErrorKey;  // NSNumber
+FOUNDATION_EXPORT NSString *const GTMNSDataZlibRemainingBytesKey;  // NSNumber
+
+typedef NS_ENUM(NSInteger, GTMNSDataZlibError) {
+  GTMNSDataZlibErrorGreaterThan32BitsToCompress = 1024,
+  // An internal zlib error.
+  // GTMNSDataZlibErrorKey will contain the error value.
+  // NSLocalizedDescriptionKey may contain an error string from zlib.
+  // Look in zlib.h for list of errors.
+  GTMNSDataZlibErrorInternal,
+  // There was left over data in the buffer that was not used.
+  // GTMNSDataZlibRemainingBytesKey will contain number of remaining bytes.
+  GTMNSDataZlibErrorDataRemaining
+};

Code Burner/Pods/GoogleToolboxForMac/Foundation/GTMNSData+zlib.m

@@ -0,0 +1,531 @@
+//
+//  GTMNSData+zlib.m
+//
+//  Copyright 2007-2008 Google Inc.
+//
+//  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.
+//
+
+#import "GTMNSData+zlib.h"
+#import <zlib.h>
+#import "GTMDefines.h"
+
+#define kChunkSize 1024
+
+NSString *const GTMNSDataZlibErrorDomain = @"com.google.GTMNSDataZlibErrorDomain";
+NSString *const GTMNSDataZlibErrorKey = @"GTMNSDataZlibErrorKey";
+NSString *const GTMNSDataZlibRemainingBytesKey = @"GTMNSDataZlibRemainingBytesKey";
+
+typedef enum {
+  CompressionModeZlib,
+  CompressionModeGzip,
+  CompressionModeRaw,
+} CompressionMode;
+
+@interface NSData (GTMZlibAdditionsPrivate)
++ (NSData *)gtm_dataByCompressingBytes:(const void *)bytes
+                                length:(NSUInteger)length
+                      compressionLevel:(int)level
+                                  mode:(CompressionMode)mode
+                                 error:(NSError **)error;
++ (NSData *)gtm_dataByInflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                           isRawData:(BOOL)isRawData
+                               error:(NSError **)error;
+@end
+
+@implementation NSData (GTMZlibAdditionsPrivate)
+
++ (NSData *)gtm_dataByCompressingBytes:(const void *)bytes
+                                length:(NSUInteger)length
+                      compressionLevel:(int)level
+                                  mode:(CompressionMode)mode
+                                 error:(NSError **)error {
+  if (!bytes || !length) {
+    return nil;
+  }
+
+#if defined(__LP64__) && __LP64__
+  // Don't support > 32bit length for 64 bit, see note in header.
+  if (length > UINT_MAX) {
+    if (error) {
+      *error = [NSError errorWithDomain:GTMNSDataZlibErrorDomain
+                                   code:GTMNSDataZlibErrorGreaterThan32BitsToCompress
+                               userInfo:nil];
+    }
+    return nil;
+  }
+#endif
+
+  if (level == Z_DEFAULT_COMPRESSION) {
+    // the default value is actually outside the range, so we have to let it
+    // through specifically.
+  } else if (level < Z_BEST_SPEED) {
+    level = Z_BEST_SPEED;
+  } else if (level > Z_BEST_COMPRESSION) {
+    level = Z_BEST_COMPRESSION;
+  }
+
+  z_stream strm;
+  bzero(&strm, sizeof(z_stream));
+
+  int memLevel = 8; // the default
+  int windowBits = 15; // the default
+  switch (mode) {
+    case CompressionModeZlib:
+      // nothing to do
+      break;
+
+    case CompressionModeGzip:
+      windowBits += 16; // enable gzip header instead of zlib header
+      break;
+
+    case CompressionModeRaw:
+      windowBits *= -1; // Negative to mean no header.
+      break;
+  }
+  int retCode;
+  if ((retCode = deflateInit2(&strm, level, Z_DEFLATED, windowBits,
+                              memLevel, Z_DEFAULT_STRATEGY)) != Z_OK) {
+    // COV_NF_START - no real way to force this in a unittest (we guard all args)
+    if (error) {
+      NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSNumber numberWithInt:retCode]
+                                                           forKey:GTMNSDataZlibErrorKey];
+      *error = [NSError errorWithDomain:GTMNSDataZlibErrorDomain
+                                   code:GTMNSDataZlibErrorInternal
+                               userInfo:userInfo];
+    }
+    return nil;
+    // COV_NF_END
+  }
+
+  // hint the size at 1/4 the input size
+  NSMutableData *result = [NSMutableData dataWithCapacity:(length/4)];
+  unsigned char output[kChunkSize];
+
+  // setup the input
+  strm.avail_in = (unsigned int)length;
+  strm.next_in = (unsigned char*)bytes;
+
+  // loop to collect the data
+  do {
+    // update what we're passing in
+    strm.avail_out = kChunkSize;
+    strm.next_out = output;
+    retCode = deflate(&strm, Z_FINISH);
+    if ((retCode != Z_OK) && (retCode != Z_STREAM_END)) {
+      // COV_NF_START - no real way to force this in a unittest
+      // (in inflate, we can feed bogus/truncated data to test, but an error
+      // here would be some internal issue w/in zlib, and there isn't any real
+      // way to test it)
+      if (error) {
+        NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSNumber numberWithInt:retCode]
+                                                             forKey:GTMNSDataZlibErrorKey];
+        *error = [NSError errorWithDomain:GTMNSDataZlibErrorDomain
+                                     code:GTMNSDataZlibErrorInternal
+                                 userInfo:userInfo];
+      }
+      deflateEnd(&strm);
+      return nil;
+      // COV_NF_END
+    }
+    // collect what we got
+    unsigned gotBack = kChunkSize - strm.avail_out;
+    if (gotBack > 0) {
+      [result appendBytes:output length:gotBack];
+    }
+
+  } while (retCode == Z_OK);
+
+  // if the loop exits, we used all input and the stream ended
+  _GTMDevAssert(strm.avail_in == 0,
+                @"thought we finished deflate w/o using all input, %u bytes left",
+                strm.avail_in);
+  _GTMDevAssert(retCode == Z_STREAM_END,
+                @"thought we finished deflate w/o getting a result of stream end, code %d",
+                retCode);
+
+  // clean up
+  deflateEnd(&strm);
+
+  return result;
+} // gtm_dataByCompressingBytes:length:compressionLevel:useGzip:
+
++ (NSData *)gtm_dataByInflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                           isRawData:(BOOL)isRawData
+                               error:(NSError **)error {
+  if (!bytes || !length) {
+    return nil;
+  }
+
+#if defined(__LP64__) && __LP64__
+  // Don't support > 32bit length for 64 bit, see note in header.
+  if (length > UINT_MAX) {
+    return nil;
+  }
+#endif
+
+  z_stream strm;
+  bzero(&strm, sizeof(z_stream));
+
+  // setup the input
+  strm.avail_in = (unsigned int)length;
+  strm.next_in = (unsigned char*)bytes;
+
+  int windowBits = 15; // 15 to enable any window size
+  if (isRawData) {
+    windowBits *= -1; // make it negative to signal no header.
+  } else {
+    windowBits += 32; // and +32 to enable zlib or gzip header detection.
+  }
+
+  int retCode;
+  if ((retCode = inflateInit2(&strm, windowBits)) != Z_OK) {
+    // COV_NF_START - no real way to force this in a unittest (we guard all args)
+    if (error) {
+      NSDictionary *userInfo = [NSDictionary dictionaryWithObject:[NSNumber numberWithInt:retCode]
+                                                           forKey:GTMNSDataZlibErrorKey];
+      *error = [NSError errorWithDomain:GTMNSDataZlibErrorDomain
+                                   code:GTMNSDataZlibErrorInternal
+                               userInfo:userInfo];
+    }
+    return nil;
+    // COV_NF_END
+  }
+
+  // hint the size at 4x the input size
+  NSMutableData *result = [NSMutableData dataWithCapacity:(length*4)];
+  unsigned char output[kChunkSize];
+
+  // loop to collect the data
+  do {
+    // update what we're passing in
+    strm.avail_out = kChunkSize;
+    strm.next_out = output;
+    retCode = inflate(&strm, Z_NO_FLUSH);
+    if ((retCode != Z_OK) && (retCode != Z_STREAM_END)) {
+      if (error) {
+        NSMutableDictionary *userInfo =
+            [NSMutableDictionary dictionaryWithObject:[NSNumber numberWithInt:retCode]
+                                               forKey:GTMNSDataZlibErrorKey];
+        if (strm.msg) {
+          NSString *message = [NSString stringWithUTF8String:strm.msg];
+          if (message) {
+            [userInfo setObject:message forKey:NSLocalizedDescriptionKey];
+          }
+        }
+        *error = [NSError errorWithDomain:GTMNSDataZlibErrorDomain
+                                     code:GTMNSDataZlibErrorInternal
+                                 userInfo:userInfo];
+      }
+      inflateEnd(&strm);
+      return nil;
+    }
+    // collect what we got
+    unsigned gotBack = kChunkSize - strm.avail_out;
+    if (gotBack > 0) {
+      [result appendBytes:output length:gotBack];
+    }
+
+  } while (retCode == Z_OK);
+
+  // make sure there wasn't more data tacked onto the end of a valid compressed
+  // stream.
+  if (strm.avail_in != 0) {
+    if (error) {
+      NSDictionary *userInfo =
+          [NSDictionary dictionaryWithObject:[NSNumber numberWithUnsignedInt:strm.avail_in]
+                                      forKey:GTMNSDataZlibRemainingBytesKey];
+      *error = [NSError errorWithDomain:GTMNSDataZlibErrorDomain
+                                   code:GTMNSDataZlibErrorDataRemaining
+                               userInfo:userInfo];
+    }
+    result = nil;
+  }
+  // the only way out of the loop was by hitting the end of the stream
+  _GTMDevAssert(retCode == Z_STREAM_END,
+                @"thought we finished inflate w/o getting a result of stream end, code %d",
+                retCode);
+
+  // clean up
+  inflateEnd(&strm);
+
+  return result;
+} // gtm_dataByInflatingBytes:length:windowBits:
+
+@end
+
+
+@implementation NSData (GTMZLibAdditions)
+
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length {
+  return [self gtm_dataByGzippingBytes:bytes length:length error:NULL];
+} // gtm_dataByGzippingBytes:length:
+
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length
+                              error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:bytes
+                                   length:length
+                         compressionLevel:Z_DEFAULT_COMPRESSION
+                                     mode:CompressionModeGzip
+                                    error:error];
+} // gtm_dataByGzippingBytes:length:error:
+
++ (NSData *)gtm_dataByGzippingData:(NSData *)data {
+  return [self gtm_dataByGzippingData:data error:NULL];
+} // gtm_dataByGzippingData:
+
++ (NSData *)gtm_dataByGzippingData:(NSData *)data error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:[data bytes]
+                                   length:[data length]
+                         compressionLevel:Z_DEFAULT_COMPRESSION
+                                     mode:CompressionModeGzip
+                                    error:error];
+} // gtm_dataByGzippingData:error:
+
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length
+                   compressionLevel:(int)level {
+  return [self gtm_dataByGzippingBytes:bytes
+                                length:length
+                      compressionLevel:level
+                                 error:NULL];
+} // gtm_dataByGzippingBytes:length:level:
+
++ (NSData *)gtm_dataByGzippingBytes:(const void *)bytes
+                             length:(NSUInteger)length
+                   compressionLevel:(int)level
+                              error:(NSError **)error{
+  return [self gtm_dataByCompressingBytes:bytes
+                                   length:length
+                         compressionLevel:level
+                                     mode:CompressionModeGzip
+                                    error:error];
+} // gtm_dataByGzippingBytes:length:level:error
+
++ (NSData *)gtm_dataByGzippingData:(NSData *)data
+                  compressionLevel:(int)level {
+  return [self gtm_dataByGzippingData:data
+                     compressionLevel:level
+                                error:NULL];
+} // gtm_dataByGzippingData:level:
+
++ (NSData *)gtm_dataByGzippingData:(NSData *)data
+                  compressionLevel:(int)level
+                             error:(NSError **)error{
+  return [self gtm_dataByCompressingBytes:[data bytes]
+                                   length:[data length]
+                         compressionLevel:level
+                                     mode:CompressionModeGzip
+                                    error:error];
+} // gtm_dataByGzippingData:level:error
+
+#pragma mark -
+
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length {
+  return [self gtm_dataByDeflatingBytes:bytes
+                                 length:length
+                                  error:NULL];
+} // gtm_dataByDeflatingBytes:length:
+
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                               error:(NSError **)error{
+  return [self gtm_dataByCompressingBytes:bytes
+                                   length:length
+                         compressionLevel:Z_DEFAULT_COMPRESSION
+                                     mode:CompressionModeZlib
+                                    error:error];
+} // gtm_dataByDeflatingBytes:length:error
+
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data {
+  return [self gtm_dataByDeflatingData:data error:NULL];
+} // gtm_dataByDeflatingData:
+
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:[data bytes]
+                                   length:[data length]
+                         compressionLevel:Z_DEFAULT_COMPRESSION
+                                     mode:CompressionModeZlib
+                                    error:error];
+} // gtm_dataByDeflatingData:
+
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                    compressionLevel:(int)level {
+  return [self gtm_dataByDeflatingBytes:bytes
+                                 length:length
+                       compressionLevel:level
+                                  error:NULL];
+} // gtm_dataByDeflatingBytes:length:level:
+
++ (NSData *)gtm_dataByDeflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                    compressionLevel:(int)level
+                               error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:bytes
+                                   length:length
+                         compressionLevel:level
+                                     mode:CompressionModeZlib
+                                    error:error];
+} // gtm_dataByDeflatingBytes:length:level:error:
+
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data
+                   compressionLevel:(int)level {
+  return [self gtm_dataByDeflatingData:data
+                      compressionLevel:level
+                                 error:NULL];
+} // gtm_dataByDeflatingData:level:
+
++ (NSData *)gtm_dataByDeflatingData:(NSData *)data
+                   compressionLevel:(int)level
+                              error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:[data bytes]
+                                   length:[data length]
+                         compressionLevel:level
+                                     mode:CompressionModeZlib
+                                    error:error];
+} // gtm_dataByDeflatingData:level:error:
+
+#pragma mark -
+
++ (NSData *)gtm_dataByInflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length {
+  return [self gtm_dataByInflatingBytes:bytes
+                                 length:length
+                                  error:NULL];
+} // gtm_dataByInflatingBytes:length:
+
++ (NSData *)gtm_dataByInflatingBytes:(const void *)bytes
+                              length:(NSUInteger)length
+                               error:(NSError **)error {
+  return [self gtm_dataByInflatingBytes:bytes
+                                 length:length
+                              isRawData:NO
+                                  error:error];
+} // gtm_dataByInflatingBytes:length:error:
+
++ (NSData *)gtm_dataByInflatingData:(NSData *)data {
+  return [self gtm_dataByInflatingData:data error:NULL];
+} // gtm_dataByInflatingData:
+
++ (NSData *)gtm_dataByInflatingData:(NSData *)data
+                              error:(NSError **)error {
+  return [self gtm_dataByInflatingBytes:[data bytes]
+                                 length:[data length]
+                              isRawData:NO
+                                  error:error];
+} // gtm_dataByInflatingData:
+
+#pragma mark -
+
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length {
+  return [self gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                    length:(NSUInteger)length
+                                     error:NULL];
+} // gtm_dataByRawDeflatingBytes:length:
+
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                                  error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:bytes
+                                   length:length
+                         compressionLevel:Z_DEFAULT_COMPRESSION
+                                     mode:CompressionModeRaw
+                                    error:error];
+} // gtm_dataByRawDeflatingBytes:length:error:
+
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data {
+  return [self gtm_dataByRawDeflatingData:data error:NULL];
+} // gtm_dataByRawDeflatingData:
+
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:[data bytes]
+                                   length:[data length]
+                         compressionLevel:Z_DEFAULT_COMPRESSION
+                                     mode:CompressionModeRaw
+                                    error:error];
+} // gtm_dataByRawDeflatingData:error:
+
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                       compressionLevel:(int)level {
+  return [self gtm_dataByRawDeflatingBytes:bytes
+                                    length:length
+                          compressionLevel:level
+                                     error:NULL];
+} // gtm_dataByRawDeflatingBytes:length:compressionLevel:
+
++ (NSData *)gtm_dataByRawDeflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                       compressionLevel:(int)level
+                                  error:(NSError **)error{
+  return [self gtm_dataByCompressingBytes:bytes
+                                   length:length
+                         compressionLevel:level
+                                     mode:CompressionModeRaw
+                                    error:error];
+} // gtm_dataByRawDeflatingBytes:length:compressionLevel:error:
+
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data
+                      compressionLevel:(int)level {
+  return [self gtm_dataByRawDeflatingData:data
+                         compressionLevel:level
+                                    error:NULL];
+} // gtm_dataByRawDeflatingData:compressionLevel:
+
++ (NSData *)gtm_dataByRawDeflatingData:(NSData *)data
+                      compressionLevel:(int)level
+                                 error:(NSError **)error {
+  return [self gtm_dataByCompressingBytes:[data bytes]
+                                   length:[data length]
+                         compressionLevel:level
+                                     mode:CompressionModeRaw
+                                    error:error];
+} // gtm_dataByRawDeflatingData:compressionLevel:error:
+
++ (NSData *)gtm_dataByRawInflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length {
+  return [self gtm_dataByInflatingBytes:bytes
+                                 length:length
+                                  error:NULL];
+} // gtm_dataByRawInflatingBytes:length:
+
++ (NSData *)gtm_dataByRawInflatingBytes:(const void *)bytes
+                                 length:(NSUInteger)length
+                                  error:(NSError **)error{
+  return [self gtm_dataByInflatingBytes:bytes
+                                 length:length
+                              isRawData:YES
+                                  error:error];
+} // gtm_dataByRawInflatingBytes:length:error:
+
++ (NSData *)gtm_dataByRawInflatingData:(NSData *)data {
+  return [self gtm_dataByRawInflatingData:data
+                                    error:NULL];
+} // gtm_dataByRawInflatingData:
+
++ (NSData *)gtm_dataByRawInflatingData:(NSData *)data
+                                 error:(NSError **)error {
+  return [self gtm_dataByInflatingBytes:[data bytes]
+                                 length:[data length]
+                              isRawData:YES
+                                  error:error];
+} // gtm_dataByRawInflatingData:error:
+
+@end

Code Burner/Pods/GoogleToolboxForMac/Foundation/GTMNSDictionary+URLArguments.h

@@ -0,0 +1,40 @@
+//
+//  GTMNSDictionary+URLArguments.h
+//
+//  Copyright 2006-2008 Google Inc.
+//
+//  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.
+//
+
+#import <Foundation/Foundation.h>
+
+/// Utility for building a URL or POST argument string.
+@interface NSDictionary (GTMNSDictionaryURLArgumentsAdditions)
+
+/// Returns a dictionary of the decoded key-value pairs in a http arguments
+/// string of the form key1=value1&key2=value2&...&keyN=valueN.
+/// Keys and values will be unescaped automatically.
+/// Only the first value for a repeated key is returned.
+///
+/// NOTE: Apps targeting iOS 8 or OS X 10.10 and later should use
+///       NSURLComponents and NSURLQueryItem to create URLs with
+///       query arguments instead of using these category methods.
++ (NSDictionary *)gtm_dictionaryWithHttpArgumentsString:(NSString *)argString;
+
+/// Gets a string representation of the dictionary in the form
+/// key1=value1&key2=value2&...&keyN=valueN, suitable for use as either
+/// URL arguments (after a '?') or POST body. Keys and values will be escaped
+/// automatically, so should be unescaped in the dictionary.
+- (NSString *)gtm_httpArgumentsString;
+
+@end

Code Burner/Pods/GoogleToolboxForMac/Foundation/GTMNSDictionary+URLArguments.m

@@ -0,0 +1,77 @@
+//
+//  GTMNSDictionary+URLArguments.m
+//
+//  Copyright 2006-2008 Google Inc.
+//
+//  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.
+//
+
+#import "GTMNSDictionary+URLArguments.h"
+#import "GTMNSString+URLArguments.h"
+#import "GTMMethodCheck.h"
+#import "GTMDefines.h"
+
+
+// Export a nonsense symbol to suppress a libtool warning when this is linked alone in a static lib.
+__attribute__((visibility("default")))
+    char GTMNSDictionaryURLArgumentsExportToSuppressLibToolWarning = 0;
+
+
+@implementation NSDictionary (GTMNSDictionaryURLArgumentsAdditions)
+
+GTM_METHOD_CHECK(NSString, gtm_stringByEscapingForURLArgument);
+GTM_METHOD_CHECK(NSString, gtm_stringByUnescapingFromURLArgument);
+
++ (NSDictionary *)gtm_dictionaryWithHttpArgumentsString:(NSString *)argString {
+  NSMutableDictionary* ret = [NSMutableDictionary dictionary];
+  NSArray* components = [argString componentsSeparatedByString:@"&"];
+  NSString* component;
+  // Use reverse order so that the first occurrence of a key replaces
+  // those subsequent.
+  for (component in [components reverseObjectEnumerator]) {
+    if ([component length] == 0)
+      continue;
+    NSRange pos = [component rangeOfString:@"="];
+    NSString *key;
+    NSString *val;
+    if (pos.location == NSNotFound) {
+      key = [component gtm_stringByUnescapingFromURLArgument];
+      val = @"";
+    } else {
+      key = [[component substringToIndex:pos.location]
+             gtm_stringByUnescapingFromURLArgument];
+      val = [[component substringFromIndex:pos.location + pos.length]
+             gtm_stringByUnescapingFromURLArgument];
+    }
+    // gtm_stringByUnescapingFromURLArgument returns nil on invalid UTF8
+    // and NSMutableDictionary raises an exception when passed nil values.
+    if (!key) key = @"";
+    if (!val) val = @"";
+    [ret setObject:val forKey:key];
+  }
+  return ret;
+}
+
+- (NSString *)gtm_httpArgumentsString {
+  NSMutableArray* arguments = [NSMutableArray arrayWithCapacity:[self count]];
+  NSString* key;
+  for (key in self) {
+    [arguments addObject:[NSString stringWithFormat:@"%@=%@",
+                          [key gtm_stringByEscapingForURLArgument],
+                          [[[self objectForKey:key] description] gtm_stringByEscapingForURLArgument]]];
+  }
+
+  return [arguments componentsJoinedByString:@"&"];
+}
+
+@end

Code Burner/Pods/GoogleToolboxForMac/Foundation/GTMNSString+URLArguments.h

@@ -0,0 +1,45 @@
+//
+//  GTMNSString+URLArguments.h
+//
+//  Copyright 2006-2008 Google Inc.
+//
+//  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.
+//
+
+#import <Foundation/Foundation.h>
+
+/// Utilities for encoding and decoding URL arguments.
+@interface NSString (GTMNSStringURLArgumentsAdditions)
+
+/// Returns a string that is escaped properly to be a URL argument.
+///
+/// This differs from stringByAddingPercentEscapesUsingEncoding: in that it
+/// will escape all the reserved characters (per RFC 3986
+/// <http://www.ietf.org/rfc/rfc3986.txt>) which
+/// stringByAddingPercentEscapesUsingEncoding would leave.
+///
+/// This will also escape '%', so this should not be used on a string that has
+/// already been escaped unless double-escaping is the desired result.
+///
+/// NOTE: Apps targeting iOS 8 or OS X 10.10 and later should use
+///       NSURLComponents and NSURLQueryItem to create properly-escaped
+///       URLs instead of using these category methods.
+- (NSString*)gtm_stringByEscapingForURLArgument;
+
+/// Returns the unescaped version of a URL argument
+///
+/// This has the same behavior as stringByReplacingPercentEscapesUsingEncoding:,
+/// except that it will also convert '+' to space.
+- (NSString*)gtm_stringByUnescapingFromURLArgument;
+
+@end

Code Burner/Pods/GoogleToolboxForMac/Foundation/GTMNSString+URLArguments.m

@@ -0,0 +1,48 @@
+//
+//  GTMNSString+URLArguments.m
+//
+//  Copyright 2006-2008 Google Inc.
+//
+//  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.
+//
+
+#import "GTMNSString+URLArguments.h"
+
+@implementation NSString (GTMNSStringURLArgumentsAdditions)
+
+- (NSString *)gtm_stringByEscapingForURLArgument {
+  // Encode all the reserved characters, per RFC 3986
+  // (<http://www.ietf.org/rfc/rfc3986.txt>)
+  CFStringRef escaped =
+    CFURLCreateStringByAddingPercentEscapes(kCFAllocatorDefault,
+                                            (CFStringRef)self,
+                                            NULL,
+                                            (CFStringRef)@"!*'();:@&=+$,/?%#[]",
+                                            kCFStringEncodingUTF8);
+#if defined(__has_feature) && __has_feature(objc_arc)
+  return CFBridgingRelease(escaped);
+#else
+  return [(NSString *)escaped autorelease];
+#endif
+}
+
+- (NSString *)gtm_stringByUnescapingFromURLArgument {
+  NSMutableString *resultString = [NSMutableString stringWithString:self];
+  [resultString replaceOccurrencesOfString:@"+"
+                                withString:@" "
+                                   options:NSLiteralSearch
+                                     range:NSMakeRange(0, [resultString length])];
+  return [resultString stringByReplacingPercentEscapesUsingEncoding:NSUTF8StringEncoding];
+}
+
+@end

Code Burner/Pods/GoogleToolboxForMac/GTMDefines.h

@@ -0,0 +1,401 @@
+//
+// GTMDefines.h
+//
+//  Copyright 2008 Google Inc.
+//
+//  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.
+//
+
+// ============================================================================
+
+#include <AvailabilityMacros.h>
+#include <TargetConditionals.h>
+
+#ifdef __OBJC__
+#include <Foundation/NSObjCRuntime.h>
+#endif  // __OBJC__
+
+#if TARGET_OS_IPHONE
+#include <Availability.h>
+#endif  // TARGET_OS_IPHONE
+
+// ----------------------------------------------------------------------------
+// CPP symbols that can be overridden in a prefix to control how the toolbox
+// is compiled.
+// ----------------------------------------------------------------------------
+
+
+// By setting the GTM_CONTAINERS_VALIDATION_FAILED_LOG and
+// GTM_CONTAINERS_VALIDATION_FAILED_ASSERT macros you can control what happens
+// when a validation fails. If you implement your own validators, you may want
+// to control their internals using the same macros for consistency.
+#ifndef GTM_CONTAINERS_VALIDATION_FAILED_ASSERT
+  #define GTM_CONTAINERS_VALIDATION_FAILED_ASSERT 0
+#endif
+
+// Ensure __has_feature and __has_extension are safe to use.
+// See http://clang-analyzer.llvm.org/annotations.html
+#ifndef __has_feature      // Optional.
+  #define __has_feature(x) 0 // Compatibility with non-clang compilers.
+#endif
+
+#ifndef __has_extension
+  #define __has_extension __has_feature // Compatibility with pre-3.0 compilers.
+#endif
+
+// Give ourselves a consistent way to do inlines.  Apple's macros even use
+// a few different actual definitions, so we're based off of the foundation
+// one.
+#if !defined(GTM_INLINE)
+  #if (defined (__GNUC__) && (__GNUC__ == 4)) || defined (__clang__)
+    #define GTM_INLINE static __inline__ __attribute__((always_inline))
+  #else
+    #define GTM_INLINE static __inline__
+  #endif
+#endif
+
+// Give ourselves a consistent way of doing externs that links up nicely
+// when mixing objc and objc++
+#if !defined (GTM_EXTERN)
+  #if defined __cplusplus
+    #define GTM_EXTERN extern "C"
+    #define GTM_EXTERN_C_BEGIN extern "C" {
+    #define GTM_EXTERN_C_END }
+  #else
+    #define GTM_EXTERN extern
+    #define GTM_EXTERN_C_BEGIN
+    #define GTM_EXTERN_C_END
+  #endif
+#endif
+
+// Give ourselves a consistent way of exporting things if we have visibility
+// set to hidden.
+#if !defined (GTM_EXPORT)
+  #define GTM_EXPORT __attribute__((visibility("default")))
+#endif
+
+// Give ourselves a consistent way of declaring something as unused. This
+// doesn't use __unused because that is only supported in gcc 4.2 and greater.
+#if !defined (GTM_UNUSED)
+#define GTM_UNUSED(x) ((void)(x))
+#endif
+
+// _GTMDevLog & _GTMDevAssert
+//
+// _GTMDevLog & _GTMDevAssert are meant to be a very lightweight shell for
+// developer level errors.  This implementation simply macros to NSLog/NSAssert.
+// It is not intended to be a general logging/reporting system.
+//
+// Please see http://code.google.com/p/google-toolbox-for-mac/wiki/DevLogNAssert
+// for a little more background on the usage of these macros.
+//
+//    _GTMDevLog           log some error/problem in debug builds
+//    _GTMDevAssert        assert if condition isn't met w/in a method/function
+//                           in all builds.
+//
+// To replace this system, just provide different macro definitions in your
+// prefix header.  Remember, any implementation you provide *must* be thread
+// safe since this could be called by anything in what ever situtation it has
+// been placed in.
+//
+
+// We only define the simple macros if nothing else has defined this.
+#ifndef _GTMDevLog
+
+#ifdef DEBUG
+  #define _GTMDevLog(...) NSLog(__VA_ARGS__)
+#else
+  #define _GTMDevLog(...) do { } while (0)
+#endif
+
+#endif // _GTMDevLog
+
+#ifndef _GTMDevAssert
+// we directly invoke the NSAssert handler so we can pass on the varargs
+// (NSAssert doesn't have a macro we can use that takes varargs)
+#if !defined(NS_BLOCK_ASSERTIONS)
+  #define _GTMDevAssert(condition, ...)                                       \
+    do {                                                                      \
+      if (!(condition)) {                                                     \
+        [[NSAssertionHandler currentHandler]                                  \
+            handleFailureInFunction:(NSString *)                              \
+                                        [NSString stringWithUTF8String:__PRETTY_FUNCTION__] \
+                               file:(NSString *)[NSString stringWithUTF8String:__FILE__]  \
+                         lineNumber:__LINE__                                  \
+                        description:__VA_ARGS__];                             \
+      }                                                                       \
+    } while(0)
+#else // !defined(NS_BLOCK_ASSERTIONS)
+  #define _GTMDevAssert(condition, ...) do { } while (0)
+#endif // !defined(NS_BLOCK_ASSERTIONS)
+
+#endif // _GTMDevAssert
+
+// _GTMCompileAssert
+//
+// Note:  Software for current compilers should just use _Static_assert directly
+// instead of this macro.
+//
+// _GTMCompileAssert is an assert that is meant to fire at compile time if you
+// want to check things at compile instead of runtime. For example if you
+// want to check that a wchar is 4 bytes instead of 2 you would use
+// _GTMCompileAssert(sizeof(wchar_t) == 4, wchar_t_is_4_bytes_on_OS_X)
+// Note that the second "arg" is not in quotes, and must be a valid processor
+// symbol in it's own right (no spaces, punctuation etc).
+
+// Wrapping this in an #ifndef allows external groups to define their own
+// compile time assert scheme.
+#ifndef _GTMCompileAssert
+  #if __has_feature(c_static_assert) || __has_extension(c_static_assert)
+    #define _GTMCompileAssert(test, msg) _Static_assert((test), #msg)
+  #else
+    // Pre-Xcode 7 support.
+    //
+    // We got this technique from here:
+    // http://unixjunkie.blogspot.com/2007/10/better-compile-time-asserts_29.html
+    #define _GTMCompileAssertSymbolInner(line, msg) _GTMCOMPILEASSERT ## line ## __ ## msg
+    #define _GTMCompileAssertSymbol(line, msg) _GTMCompileAssertSymbolInner(line, msg)
+    #define _GTMCompileAssert(test, msg) \
+      typedef char _GTMCompileAssertSymbol(__LINE__, msg) [ ((test) ? 1 : -1) ]
+  #endif  // __has_feature(c_static_assert) || __has_extension(c_static_assert)
+#endif // _GTMCompileAssert
+
+// ----------------------------------------------------------------------------
+// CPP symbols defined based on the project settings so the GTM code has
+// simple things to test against w/o scattering the knowledge of project
+// setting through all the code.
+// ----------------------------------------------------------------------------
+
+// Provide a single constant CPP symbol that all of GTM uses for ifdefing
+// iPhone code.
+#if TARGET_OS_IPHONE // iPhone SDK
+  // For iPhone specific stuff
+  #define GTM_IPHONE_SDK 1
+  #if TARGET_IPHONE_SIMULATOR
+    #define GTM_IPHONE_DEVICE 0
+    #define GTM_IPHONE_SIMULATOR 1
+  #else
+    #define GTM_IPHONE_DEVICE 1
+    #define GTM_IPHONE_SIMULATOR 0
+  #endif  // TARGET_IPHONE_SIMULATOR
+  // By default, GTM has provided it's own unittesting support, define this
+  // to use the support provided by Xcode, especially for the Xcode4 support
+  // for unittesting.
+  // This is going to be deprecated as Apple is deprecating SenTest.
+  #ifndef GTM_IPHONE_USE_SENTEST
+    #define GTM_IPHONE_USE_SENTEST 0
+  #endif
+  // Define this to use XCTest instead of OCUnit/SenTest.
+  #ifndef GTM_USING_XCTEST
+    #define GTM_USING_XCTEST 0
+  #endif
+  #if GTM_IPHONE_USE_SENTEST && GTM_USING_XCTEST
+    #error Can't define both GTM_IPHONE_USE_SENTEST and GTM_USING_XCTEST
+  #endif
+  #define GTM_MACOS_SDK 0
+#else
+  // For MacOS specific stuff
+  #define GTM_MACOS_SDK 1
+  #define GTM_IPHONE_SDK 0
+  #define GTM_IPHONE_SIMULATOR 0
+  #define GTM_IPHONE_DEVICE 0
+  #define GTM_IPHONE_USE_SENTEST 0
+  #ifndef GTM_USING_XCTEST
+    #define GTM_USING_XCTEST 0
+  #endif
+#endif
+
+// Some of our own availability macros
+#if GTM_MACOS_SDK
+#define GTM_AVAILABLE_ONLY_ON_IPHONE UNAVAILABLE_ATTRIBUTE
+#define GTM_AVAILABLE_ONLY_ON_MACOS
+#else
+#define GTM_AVAILABLE_ONLY_ON_IPHONE
+#define GTM_AVAILABLE_ONLY_ON_MACOS UNAVAILABLE_ATTRIBUTE
+#endif
+
+// GC was dropped by Apple, define the old constant incase anyone still keys
+// off of it.
+#ifndef GTM_SUPPORT_GC
+  #define GTM_SUPPORT_GC 0
+#endif
+
+// Some support for advanced clang static analysis functionality
+#ifndef NS_RETURNS_RETAINED
+  #if __has_feature(attribute_ns_returns_retained)
+    #define NS_RETURNS_RETAINED __attribute__((ns_returns_retained))
+  #else
+    #define NS_RETURNS_RETAINED
+  #endif
+#endif
+
+#ifndef NS_RETURNS_NOT_RETAINED
+  #if __has_feature(attribute_ns_returns_not_retained)
+    #define NS_RETURNS_NOT_RETAINED __attribute__((ns_returns_not_retained))
+  #else
+    #define NS_RETURNS_NOT_RETAINED
+  #endif
+#endif
+
+#ifndef CF_RETURNS_RETAINED
+  #if __has_feature(attribute_cf_returns_retained)
+    #define CF_RETURNS_RETAINED __attribute__((cf_returns_retained))
+  #else
+    #define CF_RETURNS_RETAINED
+  #endif
+#endif
+
+#ifndef CF_RETURNS_NOT_RETAINED
+  #if __has_feature(attribute_cf_returns_not_retained)
+    #define CF_RETURNS_NOT_RETAINED __attribute__((cf_returns_not_retained))
+  #else
+    #define CF_RETURNS_NOT_RETAINED
+  #endif
+#endif
+
+#ifndef NS_CONSUMED
+  #if __has_feature(attribute_ns_consumed)
+    #define NS_CONSUMED __attribute__((ns_consumed))
+  #else
+    #define NS_CONSUMED
+  #endif
+#endif
+
+#ifndef CF_CONSUMED
+  #if __has_feature(attribute_cf_consumed)
+    #define CF_CONSUMED __attribute__((cf_consumed))
+  #else
+    #define CF_CONSUMED
+  #endif
+#endif
+
+#ifndef NS_CONSUMES_SELF
+  #if __has_feature(attribute_ns_consumes_self)
+    #define NS_CONSUMES_SELF __attribute__((ns_consumes_self))
+  #else
+    #define NS_CONSUMES_SELF
+  #endif
+#endif
+
+#ifndef GTM_NONNULL
+  #if defined(__has_attribute)
+    #if __has_attribute(nonnull)
+      #define GTM_NONNULL(x) __attribute__((nonnull x))
+    #else
+      #define GTM_NONNULL(x)
+    #endif
+  #else
+    #define GTM_NONNULL(x)
+  #endif
+#endif
+
+// Invalidates the initializer from which it's called.
+#ifndef GTMInvalidateInitializer
+  #if __has_feature(objc_arc)
+    #define GTMInvalidateInitializer() \
+      do { \
+        [self class]; /* Avoid warning of dead store to |self|. */ \
+        _GTMDevAssert(NO, @"Invalid initializer."); \
+        return nil; \
+      } while (0)
+  #else
+    #define GTMInvalidateInitializer() \
+      do { \
+        [self release]; \
+        _GTMDevAssert(NO, @"Invalid initializer."); \
+        return nil; \
+      } while (0)
+  #endif
+#endif
+
+#ifndef GTMCFAutorelease
+  // GTMCFAutorelease returns an id.  In contrast, Apple's CFAutorelease returns
+  // a CFTypeRef.
+  #if __has_feature(objc_arc)
+    #define GTMCFAutorelease(x) CFBridgingRelease(x)
+  #else
+    #define GTMCFAutorelease(x) ([(id)x autorelease])
+  #endif
+#endif
+
+#ifdef __OBJC__
+
+
+// Macro to allow you to create NSStrings out of other macros.
+// #define FOO foo
+// NSString *fooString = GTM_NSSTRINGIFY(FOO);
+#if !defined (GTM_NSSTRINGIFY)
+  #define GTM_NSSTRINGIFY_INNER(x) @#x
+  #define GTM_NSSTRINGIFY(x) GTM_NSSTRINGIFY_INNER(x)
+#endif
+
+// Macro to allow fast enumeration when building for 10.5 or later, and
+// reliance on NSEnumerator for 10.4.  Remember, NSDictionary w/ FastEnumeration
+// does keys, so pick the right thing, nothing is done on the FastEnumeration
+// side to be sure you're getting what you wanted.
+#ifndef GTM_FOREACH_OBJECT
+  #if TARGET_OS_IPHONE || !(MAC_OS_X_VERSION_MIN_REQUIRED < MAC_OS_X_VERSION_10_5)
+    #define GTM_FOREACH_ENUMEREE(element, enumeration) \
+      for (element in enumeration)
+    #define GTM_FOREACH_OBJECT(element, collection) \
+      for (element in collection)
+    #define GTM_FOREACH_KEY(element, collection) \
+      for (element in collection)
+  #else
+    #define GTM_FOREACH_ENUMEREE(element, enumeration) \
+      for (NSEnumerator *_ ## element ## _enum = enumeration; \
+           (element = [_ ## element ## _enum nextObject]) != nil; )
+    #define GTM_FOREACH_OBJECT(element, collection) \
+      GTM_FOREACH_ENUMEREE(element, [collection objectEnumerator])
+    #define GTM_FOREACH_KEY(element, collection) \
+      GTM_FOREACH_ENUMEREE(element, [collection keyEnumerator])
+  #endif
+#endif
+
+// ============================================================================
+
+// GTM_SEL_STRING is for specifying selector (usually property) names to KVC
+// or KVO methods.
+// In debug it will generate warnings for undeclared selectors if
+// -Wunknown-selector is turned on.
+// In release it will have no runtime overhead.
+#ifndef GTM_SEL_STRING
+  #ifdef DEBUG
+    #define GTM_SEL_STRING(selName) NSStringFromSelector(@selector(selName))
+  #else
+    #define GTM_SEL_STRING(selName) @#selName
+  #endif  // DEBUG
+#endif  // GTM_SEL_STRING
+
+#ifndef GTM_WEAK
+#if __has_feature(objc_arc_weak)
+    // With ARC enabled, __weak means a reference that isn't implicitly
+    // retained.  __weak objects are accessed through runtime functions, so
+    // they are zeroed out, but this requires OS X 10.7+.
+    // At clang r251041+, ARC-style zeroing weak references even work in
+    // non-ARC mode.
+    #define GTM_WEAK __weak
+  #elif __has_feature(objc_arc)
+    // ARC, but targeting 10.6 or older, where zeroing weak references don't
+    // exist.
+    #define GTM_WEAK __unsafe_unretained
+  #else
+    // With manual reference counting, __weak used to be silently ignored.
+    // clang r251041 gives it the ARC semantics instead.  This means they
+    // now require a deployment target of 10.7, while some clients of GTM
+    // still target 10.6.  In these cases, expand to __unsafe_unretained instead
+    #define GTM_WEAK
+  #endif
+#endif
+
+#endif  // __OBJC__

Code Burner/Pods/GoogleToolboxForMac/LICENSE

@@ -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.

Code Burner/Pods/GoogleToolboxForMac/README.md

@@ -0,0 +1,15 @@
+# GTM: Google Toolbox for Mac #
+
+**Project site** <https://github.com/google/google-toolbox-for-mac><br>
+**Discussion group** <http://groups.google.com/group/google-toolbox-for-mac>
+
+# Google Toolbox for Mac #
+
+A collection of source from different Google projects that may be of use to
+developers working other iOS or OS X projects.
+
+If you find a problem/bug or want a new feature to be included in the Google
+Toolbox for Mac, please join the
+[discussion group](http://groups.google.com/group/google-toolbox-for-mac)
+or submit an
+[issue](https://github.com/google/google-toolbox-for-mac/issues).

Code Burner/Pods/Headers/Private/Firebase/Firebase.h

@@ -0,0 +1 @@
+../../../Firebase/Core/Sources/Firebase.h

Code Burner/Pods/Headers/Private/FirebaseInstanceID/FIRInstanceID.h

@@ -0,0 +1 @@
+../../../FirebaseInstanceID/Sources/FIRInstanceID.h

Code Burner/Pods/Headers/Private/GTMSessionFetcher/GTMSessionFetcher.h

@@ -0,0 +1 @@
+../../../GTMSessionFetcher/Source/GTMSessionFetcher.h

Code Burner/Pods/Headers/Private/GTMSessionFetcher/GTMSessionFetcherLogging.h

@@ -0,0 +1 @@
+../../../GTMSessionFetcher/Source/GTMSessionFetcherLogging.h

Code Burner/Pods/Headers/Private/GTMSessionFetcher/GTMSessionFetcherService.h

@@ -0,0 +1 @@
+../../../GTMSessionFetcher/Source/GTMSessionFetcherService.h

Code Burner/Pods/Headers/Private/GTMSessionFetcher/GTMSessionUploadFetcher.h

@@ -0,0 +1 @@
+../../../GTMSessionFetcher/Source/GTMSessionUploadFetcher.h

Code Burner/Pods/Headers/Private/GoogleToolboxForMac/GTMDebugSelectorValidation.h

@@ -0,0 +1 @@
+../../../GoogleToolboxForMac/DebugUtils/GTMDebugSelectorValidation.h

Code Burner/Pods/Headers/Private/GoogleToolboxForMac/GTMDebugThreadValidation.h

@@ -0,0 +1 @@
+../../../GoogleToolboxForMac/DebugUtils/GTMDebugThreadValidation.h

Code Burner/Pods/Headers/Private/GoogleToolboxForMac/GTMDefines.h

@@ -0,0 +1 @@
+../../../GoogleToolboxForMac/GTMDefines.h

Code Burner/Pods/Headers/Private/GoogleToolboxForMac/GTMMethodCheck.h

@@ -0,0 +1 @@
+../../../GoogleToolboxForMac/DebugUtils/GTMMethodCheck.h

Code Burner/Pods/Headers/Private/GoogleToolboxForMac/GTMNSData+zlib.h

@@ -0,0 +1 @@
+../../../GoogleToolboxForMac/Foundation/GTMNSData+zlib.h

Code Burner/Pods/Headers/Private/GoogleToolboxForMac/GTMNSDictionary+URLArguments.h

@@ -0,0 +1 @@
+../../../GoogleToolboxForMac/Foundation/GTMNSDictionary+URLArguments.h

Code Burner/Pods/Headers/Private/GoogleToolboxForMac/GTMNSString+URLArguments.h

@@ -0,0 +1 @@
+../../../GoogleToolboxForMac/Foundation/GTMNSString+URLArguments.h

Code Burner/Pods/Headers/Public/FirebaseAnalytics/FirebaseAnalytics/FIRAnalytics+AppDelegate.h

@@ -0,0 +1 @@
+../../../../FirebaseAnalytics/Frameworks/frameworks/FirebaseAnalytics.framework/Headers/FIRAnalytics+AppDelegate.h

Code Burner/Pods/Headers/Public/FirebaseAnalytics/FirebaseAnalytics/FIRAnalytics.h

@@ -0,0 +1 @@
+../../../../FirebaseAnalytics/Frameworks/frameworks/FirebaseAnalytics.framework/Headers/FIRAnalytics.h

Code Burner/Pods/Headers/Public/FirebaseAnalytics/FirebaseAnalytics/FIRAnalyticsConfiguration.h

@@ -0,0 +1 @@
+../../../../FirebaseAnalytics/Frameworks/frameworks/FirebaseAnalytics.framework/Headers/FIRAnalyticsConfiguration.h

Code Burner/Pods/Headers/Public/FirebaseAnalytics/FirebaseAnalytics/FIRApp.h

@@ -0,0 +1 @@
+../../../../FirebaseAnalytics/Frameworks/frameworks/FirebaseAnalytics.framework/Headers/FIRApp.h

Code Burner/Pods/Headers/Public/FirebaseAnalytics/FirebaseAnalytics/FIRConfiguration.h

@@ -0,0 +1 @@
+../../../../FirebaseAnalytics/Frameworks/frameworks/FirebaseAnalytics.framework/Headers/FIRConfiguration.h

Code Burner/Pods/Headers/Public/FirebaseAnalytics/FirebaseAnalytics/FIREventNames.h

@@ -0,0 +1 @@
+../../../../FirebaseAnalytics/Frameworks/frameworks/FirebaseAnalytics.framework/Headers/FIREventNames.h

Code Burner/Pods/Headers/Public/FirebaseAnalytics/FirebaseAnalytics/FIROptions.h

@@ -0,0 +1 @@
+../../../../FirebaseAnalytics/Frameworks/frameworks/FirebaseAnalytics.framework/Headers/FIROptions.h

Code Burner/Pods/Headers/Public/FirebaseAnalytics/FirebaseAnalytics/FIRParameterNames.h

@@ -0,0 +1 @@
+../../../../FirebaseAnalytics/Frameworks/frameworks/FirebaseAnalytics.framework/Headers/FIRParameterNames.h

Code Burner/Pods/Headers/Public/FirebaseAnalytics/FirebaseAnalytics/FIRUserPropertyNames.h

@@ -0,0 +1 @@
+../../../../FirebaseAnalytics/Frameworks/frameworks/FirebaseAnalytics.framework/Headers/FIRUserPropertyNames.h

Code Burner/Pods/Headers/Public/FirebaseAnalytics/FirebaseAnalytics/FirebaseAnalytics.h

@@ -0,0 +1 @@
+../../../../FirebaseAnalytics/Frameworks/frameworks/FirebaseAnalytics.framework/Headers/FirebaseAnalytics.h

Code Burner/Pods/Headers/Public/FirebaseAuth/FirebaseAuth/FIRAuth.h

@@ -0,0 +1 @@
+../../../../FirebaseAuth/Frameworks/frameworks/FirebaseAuth.framework/Headers/FIRAuth.h

Code Burner/Pods/Headers/Public/FirebaseAuth/FirebaseAuth/FIRAuthCredential.h

@@ -0,0 +1 @@
+../../../../FirebaseAuth/Frameworks/frameworks/FirebaseAuth.framework/Headers/FIRAuthCredential.h

Code Burner/Pods/Headers/Public/FirebaseAuth/FirebaseAuth/FIRAuthErrors.h

@@ -0,0 +1 @@
+../../../../FirebaseAuth/Frameworks/frameworks/FirebaseAuth.framework/Headers/FIRAuthErrors.h

Code Burner/Pods/Headers/Public/FirebaseAuth/FirebaseAuth/FIREmailPasswordAuthProvider.h

@@ -0,0 +1 @@
+../../../../FirebaseAuth/Frameworks/frameworks/FirebaseAuth.framework/Headers/FIREmailPasswordAuthProvider.h

Code Burner/Pods/Headers/Public/FirebaseAuth/FirebaseAuth/FIRFacebookAuthProvider.h

@@ -0,0 +1 @@
+../../../../FirebaseAuth/Frameworks/frameworks/FirebaseAuth.framework/Headers/FIRFacebookAuthProvider.h

Code Burner/Pods/Headers/Public/FirebaseAuth/FirebaseAuth/FIRGitHubAuthProvider.h

@@ -0,0 +1 @@
+../../../../FirebaseAuth/Frameworks/frameworks/FirebaseAuth.framework/Headers/FIRGitHubAuthProvider.h

Code Burner/Pods/Headers/Public/FirebaseAuth/FirebaseAuth/FIRGoogleAuthProvider.h

@@ -0,0 +1 @@
+../../../../FirebaseAuth/Frameworks/frameworks/FirebaseAuth.framework/Headers/FIRGoogleAuthProvider.h

Code Burner/Pods/Headers/Public/FirebaseAuth/FirebaseAuth/FIRTwitterAuthProvider.h

@@ -0,0 +1 @@
+../../../../FirebaseAuth/Frameworks/frameworks/FirebaseAuth.framework/Headers/FIRTwitterAuthProvider.h

Code Burner/Pods/Headers/Public/FirebaseAuth/FirebaseAuth/FIRUser.h

@@ -0,0 +1 @@
+../../../../FirebaseAuth/Frameworks/frameworks/FirebaseAuth.framework/Headers/FIRUser.h

Code Burner/Pods/Headers/Public/FirebaseAuth/FirebaseAuth/FIRUserInfo.h

@@ -0,0 +1 @@
+../../../../FirebaseAuth/Frameworks/frameworks/FirebaseAuth.framework/Headers/FIRUserInfo.h

Code Burner/Pods/Headers/Public/FirebaseAuth/FirebaseAuth/FirebaseAuth.h

@@ -0,0 +1 @@
+../../../../FirebaseAuth/Frameworks/frameworks/FirebaseAuth.framework/Headers/FirebaseAuth.h

Code Burner/Pods/Headers/Public/FirebaseCore/FirebaseCore/FIRAnalyticsConfiguration.h

@@ -0,0 +1 @@
+../../../../FirebaseCore/Frameworks/frameworks/FirebaseCore.framework/Headers/FIRAnalyticsConfiguration.h

Code Burner/Pods/Headers/Public/FirebaseCore/FirebaseCore/FIRApp.h

@@ -0,0 +1 @@
+../../../../FirebaseCore/Frameworks/frameworks/FirebaseCore.framework/Headers/FIRApp.h

Code Burner/Pods/Headers/Public/FirebaseCore/FirebaseCore/FIRConfiguration.h

@@ -0,0 +1 @@
+../../../../FirebaseCore/Frameworks/frameworks/FirebaseCore.framework/Headers/FIRConfiguration.h

Code Burner/Pods/Headers/Public/FirebaseCore/FirebaseCore/FIROptions.h

@@ -0,0 +1 @@
+../../../../FirebaseCore/Frameworks/frameworks/FirebaseCore.framework/Headers/FIROptions.h

Code Burner/Pods/Headers/Public/FirebaseCore/FirebaseCore/FirebaseCore.h

@@ -0,0 +1 @@
+../../../../FirebaseCore/Frameworks/frameworks/FirebaseCore.framework/Headers/FirebaseCore.h

Code Burner/Pods/Headers/Public/FirebaseDatabase/FirebaseDatabase/FIRDataEventType.h

@@ -0,0 +1 @@
+../../../../FirebaseDatabase/Frameworks/FirebaseDatabase.framework/Headers/FIRDataEventType.h

Code Burner/Pods/Headers/Public/FirebaseDatabase/FirebaseDatabase/FIRDataSnapshot.h

@@ -0,0 +1 @@
+../../../../FirebaseDatabase/Frameworks/FirebaseDatabase.framework/Headers/FIRDataSnapshot.h

Code Burner/Pods/Headers/Public/FirebaseDatabase/FirebaseDatabase/FIRDatabase.h

@@ -0,0 +1 @@
+../../../../FirebaseDatabase/Frameworks/FirebaseDatabase.framework/Headers/FIRDatabase.h

Code Burner/Pods/Headers/Public/FirebaseDatabase/FirebaseDatabase/FIRDatabaseQuery.h

@@ -0,0 +1 @@
+../../../../FirebaseDatabase/Frameworks/FirebaseDatabase.framework/Headers/FIRDatabaseQuery.h

Code Burner/Pods/Headers/Public/FirebaseDatabase/FirebaseDatabase/FIRDatabaseReference.h

@@ -0,0 +1 @@
+../../../../FirebaseDatabase/Frameworks/FirebaseDatabase.framework/Headers/FIRDatabaseReference.h

Code Burner/Pods/Headers/Public/FirebaseDatabase/FirebaseDatabase/FIRMutableData.h

@@ -0,0 +1 @@
+../../../../FirebaseDatabase/Frameworks/FirebaseDatabase.framework/Headers/FIRMutableData.h

Code Burner/Pods/Headers/Public/FirebaseDatabase/FirebaseDatabase/FIRServerValue.h

@@ -0,0 +1 @@
+../../../../FirebaseDatabase/Frameworks/FirebaseDatabase.framework/Headers/FIRServerValue.h

Code Burner/Pods/Headers/Public/FirebaseDatabase/FirebaseDatabase/FIRTransactionResult.h

@@ -0,0 +1 @@
+../../../../FirebaseDatabase/Frameworks/FirebaseDatabase.framework/Headers/FIRTransactionResult.h

Code Burner/Pods/Headers/Public/FirebaseDatabase/FirebaseDatabase/FirebaseDatabase.h

@@ -0,0 +1 @@
+../../../../FirebaseDatabase/Frameworks/FirebaseDatabase.framework/Headers/FirebaseDatabase.h

Code Burner/Pods/Headers/Public/FirebaseInstanceID/FIRInstanceID.h

@@ -0,0 +1 @@
+../../../FirebaseInstanceID/Sources/FIRInstanceID.h

Code Burner/Pods/Headers/Public/FirebaseInstanceID/FirebaseInstanceID/FIRInstanceID.h

@@ -0,0 +1 @@
+../../../../FirebaseInstanceID/Frameworks/frameworks/FirebaseInstanceID.framework/Headers/FIRInstanceID.h

Code Burner/Pods/Headers/Public/FirebaseInstanceID/FirebaseInstanceID/FirebaseInstanceID.h

@@ -0,0 +1 @@
+../../../../FirebaseInstanceID/Frameworks/frameworks/FirebaseInstanceID.framework/Headers/FirebaseInstanceID.h

Code Burner/Pods/Pods.xcodeproj/project.pbxproj

@@ -0,0 +1,882 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 46;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		0E6F2758E5743B053E54C51B0D236AF0 /* GTMSessionUploadFetcher.h in Headers */ = {isa = PBXBuildFile; fileRef = 51D29E10113F59F8B03D62B62AC507C9 /* GTMSessionUploadFetcher.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		1235AC549ED1B1EF40635602DCF8B4D5 /* GTMSessionFetcherLogging.h in Headers */ = {isa = PBXBuildFile; fileRef = 43D4176DA600C72D135D59B357970934 /* GTMSessionFetcherLogging.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		226B1BFF4E3FC473A1C88F2CFD77C9AF /* GTMDebugThreadValidation.h in Headers */ = {isa = PBXBuildFile; fileRef = AF9AF0A6BF948AD226A8865B09C54090 /* GTMDebugThreadValidation.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		2583A3E4525E67AC3D64936F3952D567 /* Pods-Task Burner-dummy.m in Sources */ = {isa = PBXBuildFile; fileRef = 84D81D90A049FA6F1EC648D7C77F549B /* Pods-Task Burner-dummy.m */; };
+		26BE741AD59EF185570AC9C853F44FAD /* GTMNSData+zlib.h in Headers */ = {isa = PBXBuildFile; fileRef = F53D6A595711D2D2F72DF8A1C69F4B76 /* GTMNSData+zlib.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		3328D6AA0A6DD5371B63ECAD18718F3F /* GoogleToolboxForMac-dummy.m in Sources */ = {isa = PBXBuildFile; fileRef = ACE77093C121EA932E8AC513F0E9F7CF /* GoogleToolboxForMac-dummy.m */; };
+		476D901118FCE3506AF5ECEFC743403B /* GTMDebugSelectorValidation.h in Headers */ = {isa = PBXBuildFile; fileRef = 198915C0CA44B0356C9834B46191A039 /* GTMDebugSelectorValidation.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		522C0FE7197A2D7D3D925ADA58429D05 /* GTMSessionUploadFetcher.m in Sources */ = {isa = PBXBuildFile; fileRef = F4566B7D99D538A8B56C58885B5C7AF9 /* GTMSessionUploadFetcher.m */; settings = {COMPILER_FLAGS = "-w -Xanalyzer -analyzer-disable-all-checks"; }; };
+		5353CD4CF7B378621E34EA62C699E40F /* GTMNSDictionary+URLArguments.m in Sources */ = {isa = PBXBuildFile; fileRef = 76CE7EF4EC993A5A43620E9D17CA2672 /* GTMNSDictionary+URLArguments.m */; settings = {COMPILER_FLAGS = "-DOS_OBJECT_USE_OBJC=0 -w -Xanalyzer -analyzer-disable-all-checks"; }; };
+		5E255A5B5203BE00C7B9E4D2E0D3BDC7 /* GTMMethodCheck.h in Headers */ = {isa = PBXBuildFile; fileRef = ECD0F1EFC7009C67FE0D11DB12122952 /* GTMMethodCheck.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		66C6BF3F708DA86153C829B78B3DA77A /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B4690263E3C2DD3C24DEAC554FFBD486 /* Foundation.framework */; };
+		6C262944569C29D04DFA3C5F21494AAB /* GTMNSDictionary+URLArguments.h in Headers */ = {isa = PBXBuildFile; fileRef = 79096A79B53D03AD3665115E0DA95A45 /* GTMNSDictionary+URLArguments.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		74B88A8B5B43AE22CE208F1AF9315336 /* GTMSessionFetcher-dummy.m in Sources */ = {isa = PBXBuildFile; fileRef = 4DD91002BCF9915312AD20281FD51435 /* GTMSessionFetcher-dummy.m */; };
+		9B3794E275C6348A291A1E0A52CAF113 /* GTMSessionFetcher.m in Sources */ = {isa = PBXBuildFile; fileRef = 65C61B699F2853C1A38C4E2D8F98EF63 /* GTMSessionFetcher.m */; settings = {COMPILER_FLAGS = "-w -Xanalyzer -analyzer-disable-all-checks"; }; };
+		9BB31E94CF2D3BEB22EEC2E0D2147C64 /* GTMSessionFetcherService.m in Sources */ = {isa = PBXBuildFile; fileRef = AA060057AF151DB56F7677AF4F95B457 /* GTMSessionFetcherService.m */; settings = {COMPILER_FLAGS = "-w -Xanalyzer -analyzer-disable-all-checks"; }; };
+		A46AF96BFE3E00583C3C2AB6C1322D7B /* GTMDefines.h in Headers */ = {isa = PBXBuildFile; fileRef = 3EB8DA35765DD5E8F31B2FBF56495D2A /* GTMDefines.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		ACBF3E2E9A6B3E9FD859BF001F20D694 /* GTMNSString+URLArguments.m in Sources */ = {isa = PBXBuildFile; fileRef = 1F7865566B8E2ED0B4F7BE5D7CBC7122 /* GTMNSString+URLArguments.m */; settings = {COMPILER_FLAGS = "-fno-objc-arc -w -Xanalyzer -analyzer-disable-all-checks"; }; };
+		B4B084A9C602985BE7858EA801AD4382 /* GTMSessionFetcherService.h in Headers */ = {isa = PBXBuildFile; fileRef = A65BC05DA1122277E055FA1A3EE4AFAF /* GTMSessionFetcherService.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		CDA0F61C3BD605E63D0500A1A0574969 /* GTMSessionFetcherLogging.m in Sources */ = {isa = PBXBuildFile; fileRef = 97D84A1EA42F010E0CAB6B5D20A6DC9C /* GTMSessionFetcherLogging.m */; settings = {COMPILER_FLAGS = "-w -Xanalyzer -analyzer-disable-all-checks"; }; };
+		E071ED04676790AFF262727DB6BC5DE1 /* GTMNSData+zlib.m in Sources */ = {isa = PBXBuildFile; fileRef = 450D20C8A4B2C00E0E699329C336A410 /* GTMNSData+zlib.m */; settings = {COMPILER_FLAGS = "-DOS_OBJECT_USE_OBJC=0 -w -Xanalyzer -analyzer-disable-all-checks"; }; };
+		E723E1309A6A0D437B3AB3C392BF1F93 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B4690263E3C2DD3C24DEAC554FFBD486 /* Foundation.framework */; };
+		E84DEF53F8F01BAF747EB387654EC0AC /* GTMNSString+URLArguments.h in Headers */ = {isa = PBXBuildFile; fileRef = 271F3453FC8A4680AD9B2B2756C3DC8E /* GTMNSString+URLArguments.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		E982A741CDD1A8CC804FC7F20E5C006F /* GTMSessionFetcher.h in Headers */ = {isa = PBXBuildFile; fileRef = 453FA2537F543AD7C2DD6562A32E8B26 /* GTMSessionFetcher.h */; settings = {ATTRIBUTES = (Public, ); }; };
+		F3E77AA87F046EA6488343E942699FC2 /* Foundation.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = B4690263E3C2DD3C24DEAC554FFBD486 /* Foundation.framework */; };
+		FDA904E57877210782AFC6E37383A93C /* Security.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = CAFD15069DBFFAF7E7CD48183E2D230C /* Security.framework */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		402CF8AFD3F030BFD607E1A1FF3CDDA0 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = D41D8CD98F00B204E9800998ECF8427E /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = 58E7450DB13C5ECCE92D3C0DF7CF0903;
+			remoteInfo = GoogleToolboxForMac;
+		};
+		46A250E2AE529E111F158A88D1FA619B /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = D41D8CD98F00B204E9800998ECF8427E /* Project object */;
+			proxyType = 1;
+			remoteGlobalIDString = DE868725B18AE240E550C5515AE66BC4;
+			remoteInfo = GTMSessionFetcher;
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXFileReference section */
+		01D4834F06DB740C2829D5D6876C60E7 /* libGoogleToolboxForMac.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; name = libGoogleToolboxForMac.a; path = libGoogleToolboxForMac.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		0AF57663DC977510D58585C2C7095993 /* FIRInstanceID.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = FIRInstanceID.h; path = Sources/FIRInstanceID.h; sourceTree = "<group>"; };
+		1681F0B4DDE056E943C58F99F7F8D96E /* GoogleToolboxForMac-prefix.pch */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; path = "GoogleToolboxForMac-prefix.pch"; sourceTree = "<group>"; };
+		198915C0CA44B0356C9834B46191A039 /* GTMDebugSelectorValidation.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = GTMDebugSelectorValidation.h; path = DebugUtils/GTMDebugSelectorValidation.h; sourceTree = "<group>"; };
+		1E12D9E778B2314B4E96D753DE05B80B /* FirebaseAnalytics.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = FirebaseAnalytics.framework; path = Frameworks/frameworks/FirebaseAnalytics.framework; sourceTree = "<group>"; };
+		1F7865566B8E2ED0B4F7BE5D7CBC7122 /* GTMNSString+URLArguments.m */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.objc; name = "GTMNSString+URLArguments.m"; path = "Foundation/GTMNSString+URLArguments.m"; sourceTree = "<group>"; };
+		271F3453FC8A4680AD9B2B2756C3DC8E /* GTMNSString+URLArguments.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = "GTMNSString+URLArguments.h"; path = "Foundation/GTMNSString+URLArguments.h"; sourceTree = "<group>"; };
+		3302A115413B703F3744584FED312A14 /* Pods-Task Burner.release.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; path = "Pods-Task Burner.release.xcconfig"; sourceTree = "<group>"; };
+		396FAFC8A93A407C7062DA87A02001A5 /* FirebaseInstanceID.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = FirebaseInstanceID.framework; path = Frameworks/frameworks/FirebaseInstanceID.framework; sourceTree = "<group>"; };
+		3A9F1E2FEAB05086AE95B22A86CB9DFC /* Firebase.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = Firebase.h; path = Core/Sources/Firebase.h; sourceTree = "<group>"; };
+		3C7420535ACBD3D143B95490196FF34F /* Pods-Task Burner-acknowledgements.markdown */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text; path = "Pods-Task Burner-acknowledgements.markdown"; sourceTree = "<group>"; };
+		3EB8DA35765DD5E8F31B2FBF56495D2A /* GTMDefines.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; path = GTMDefines.h; sourceTree = "<group>"; };
+		43D4176DA600C72D135D59B357970934 /* GTMSessionFetcherLogging.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = GTMSessionFetcherLogging.h; path = Source/GTMSessionFetcherLogging.h; sourceTree = "<group>"; };
+		450D20C8A4B2C00E0E699329C336A410 /* GTMNSData+zlib.m */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.objc; name = "GTMNSData+zlib.m"; path = "Foundation/GTMNSData+zlib.m"; sourceTree = "<group>"; };
+		453FA2537F543AD7C2DD6562A32E8B26 /* GTMSessionFetcher.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = GTMSessionFetcher.h; path = Source/GTMSessionFetcher.h; sourceTree = "<group>"; };
+		4DD91002BCF9915312AD20281FD51435 /* GTMSessionFetcher-dummy.m */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.objc; path = "GTMSessionFetcher-dummy.m"; sourceTree = "<group>"; };
+		51D29E10113F59F8B03D62B62AC507C9 /* GTMSessionUploadFetcher.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = GTMSessionUploadFetcher.h; path = Source/GTMSessionUploadFetcher.h; sourceTree = "<group>"; };
+		5696FC1316CB903A341D34EB9AFB06B4 /* GTMSessionFetcher-prefix.pch */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; path = "GTMSessionFetcher-prefix.pch"; sourceTree = "<group>"; };
+		632CA29AC91DB6DF4F279FCBC9EC20D3 /* FirebaseCore.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = FirebaseCore.framework; path = Frameworks/frameworks/FirebaseCore.framework; sourceTree = "<group>"; };
+		65C61B699F2853C1A38C4E2D8F98EF63 /* GTMSessionFetcher.m */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.objc; name = GTMSessionFetcher.m; path = Source/GTMSessionFetcher.m; sourceTree = "<group>"; };
+		6B344812936B5768866A3C61F687744F /* GTMSessionFetcher.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; path = GTMSessionFetcher.xcconfig; sourceTree = "<group>"; };
+		7358C9A3231ACC54052C7EF3484C7768 /* GoogleInterchangeUtilities.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = GoogleInterchangeUtilities.framework; path = Frameworks/frameworks/GoogleInterchangeUtilities.framework; sourceTree = "<group>"; };
+		76C5068038AD5399FF8EB3D8A3E6D0F8 /* libPods-Task Burner.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; name = "libPods-Task Burner.a"; path = "libPods-Task Burner.a"; sourceTree = BUILT_PRODUCTS_DIR; };
+		76CE7EF4EC993A5A43620E9D17CA2672 /* GTMNSDictionary+URLArguments.m */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.objc; name = "GTMNSDictionary+URLArguments.m"; path = "Foundation/GTMNSDictionary+URLArguments.m"; sourceTree = "<group>"; };
+		79096A79B53D03AD3665115E0DA95A45 /* GTMNSDictionary+URLArguments.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = "GTMNSDictionary+URLArguments.h"; path = "Foundation/GTMNSDictionary+URLArguments.h"; sourceTree = "<group>"; };
+		84D81D90A049FA6F1EC648D7C77F549B /* Pods-Task Burner-dummy.m */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.objc; path = "Pods-Task Burner-dummy.m"; sourceTree = "<group>"; };
+		93A4A3777CF96A4AAC1D13BA6DCCEA73 /* Podfile */ = {isa = PBXFileReference; explicitFileType = text.script.ruby; includeInIndex = 1; lastKnownFileType = text; name = Podfile; path = ../Podfile; sourceTree = SOURCE_ROOT; xcLanguageSpecificationIdentifier = xcode.lang.ruby; };
+		97D84A1EA42F010E0CAB6B5D20A6DC9C /* GTMSessionFetcherLogging.m */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.objc; name = GTMSessionFetcherLogging.m; path = Source/GTMSessionFetcherLogging.m; sourceTree = "<group>"; };
+		9E8ACF90A25AEB15F1010B7B6E9EC3F8 /* libGTMSessionFetcher.a */ = {isa = PBXFileReference; explicitFileType = archive.ar; includeInIndex = 0; name = libGTMSessionFetcher.a; path = libGTMSessionFetcher.a; sourceTree = BUILT_PRODUCTS_DIR; };
+		A65BC05DA1122277E055FA1A3EE4AFAF /* GTMSessionFetcherService.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = GTMSessionFetcherService.h; path = Source/GTMSessionFetcherService.h; sourceTree = "<group>"; };
+		AA060057AF151DB56F7677AF4F95B457 /* GTMSessionFetcherService.m */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.objc; name = GTMSessionFetcherService.m; path = Source/GTMSessionFetcherService.m; sourceTree = "<group>"; };
+		ACE77093C121EA932E8AC513F0E9F7CF /* GoogleToolboxForMac-dummy.m */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.objc; path = "GoogleToolboxForMac-dummy.m"; sourceTree = "<group>"; };
+		AF9AF0A6BF948AD226A8865B09C54090 /* GTMDebugThreadValidation.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = GTMDebugThreadValidation.h; path = DebugUtils/GTMDebugThreadValidation.h; sourceTree = "<group>"; };
+		B0BCEB2BE215955E08FBABAC2F342963 /* GoogleToolboxForMac.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; path = GoogleToolboxForMac.xcconfig; sourceTree = "<group>"; };
+		B4690263E3C2DD3C24DEAC554FFBD486 /* Foundation.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Foundation.framework; path = Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS10.0.sdk/System/Library/Frameworks/Foundation.framework; sourceTree = DEVELOPER_DIR; };
+		BDEFD270EB956D87018E680BD7111D50 /* FirebaseAuth.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = FirebaseAuth.framework; path = Frameworks/frameworks/FirebaseAuth.framework; sourceTree = "<group>"; };
+		C76746CE34097BBFFE14EDA4648E655E /* FirebaseDatabase.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = FirebaseDatabase.framework; path = Frameworks/FirebaseDatabase.framework; sourceTree = "<group>"; };
+		C971B9EA7E7B9214492546F7D4052C0F /* Pods-Task Burner.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; path = "Pods-Task Burner.debug.xcconfig"; sourceTree = "<group>"; };
+		CAFD15069DBFFAF7E7CD48183E2D230C /* Security.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Security.framework; path = Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS10.0.sdk/System/Library/Frameworks/Security.framework; sourceTree = DEVELOPER_DIR; };
+		DAF48B844D73C0CDD7693B471096C430 /* Pods-Task Burner-resources.sh */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.script.sh; path = "Pods-Task Burner-resources.sh"; sourceTree = "<group>"; };
+		DC59A955ADA37DD0F6FDDF181FAF3E77 /* GoogleSymbolUtilities.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = GoogleSymbolUtilities.framework; path = Frameworks/frameworks/GoogleSymbolUtilities.framework; sourceTree = "<group>"; };
+		E10345C14514E28C3AD064233A3A4D9F /* Pods-Task Burner-frameworks.sh */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.script.sh; path = "Pods-Task Burner-frameworks.sh"; sourceTree = "<group>"; };
+		ECD0F1EFC7009C67FE0D11DB12122952 /* GTMMethodCheck.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = GTMMethodCheck.h; path = DebugUtils/GTMMethodCheck.h; sourceTree = "<group>"; };
+		F4566B7D99D538A8B56C58885B5C7AF9 /* GTMSessionUploadFetcher.m */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.objc; name = GTMSessionUploadFetcher.m; path = Source/GTMSessionUploadFetcher.m; sourceTree = "<group>"; };
+		F53D6A595711D2D2F72DF8A1C69F4B76 /* GTMNSData+zlib.h */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = sourcecode.c.h; name = "GTMNSData+zlib.h"; path = "Foundation/GTMNSData+zlib.h"; sourceTree = "<group>"; };
+		FF727D42E333859869F3AB7B03C5A46C /* Pods-Task Burner-acknowledgements.plist */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.plist.xml; path = "Pods-Task Burner-acknowledgements.plist"; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		39DAA8001E09064D451C0B69AE13E8EF /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				E723E1309A6A0D437B3AB3C392BF1F93 /* Foundation.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		8D2BE8CE5663DF1EA1CF1CC5269C6067 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				66C6BF3F708DA86153C829B78B3DA77A /* Foundation.framework in Frameworks */,
+				FDA904E57877210782AFC6E37383A93C /* Security.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		E468DEE3816A9E9ED082166AC0F3EAAB /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				F3E77AA87F046EA6488343E942699FC2 /* Foundation.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		0FEE339796C999F898C7C3F9AD4291A3 /* GoogleSymbolUtilities */ = {
+			isa = PBXGroup;
+			children = (
+				EE95B9FE529E517EC9845CBD7B603700 /* Frameworks */,
+			);
+			name = GoogleSymbolUtilities;
+			path = GoogleSymbolUtilities;
+			sourceTree = "<group>";
+		};
+		19D2B8153A76EF4EA5D4C72988567FC5 /* NSString+URLArguments */ = {
+			isa = PBXGroup;
+			children = (
+				271F3453FC8A4680AD9B2B2756C3DC8E /* GTMNSString+URLArguments.h */,
+				1F7865566B8E2ED0B4F7BE5D7CBC7122 /* GTMNSString+URLArguments.m */,
+			);
+			name = "NSString+URLArguments";
+			sourceTree = "<group>";
+		};
+		1ED5EA34C05D3C08A1CBF967F58EB3F3 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				396FAFC8A93A407C7062DA87A02001A5 /* FirebaseInstanceID.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		1F82E856F6366BC55E8AA15B58F769A2 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				7358C9A3231ACC54052C7EF3484C7768 /* GoogleInterchangeUtilities.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		215C9F496CE94E15A70809F1F5273BF1 /* Core */ = {
+			isa = PBXGroup;
+			children = (
+				453FA2537F543AD7C2DD6562A32E8B26 /* GTMSessionFetcher.h */,
+				65C61B699F2853C1A38C4E2D8F98EF63 /* GTMSessionFetcher.m */,
+				43D4176DA600C72D135D59B357970934 /* GTMSessionFetcherLogging.h */,
+				97D84A1EA42F010E0CAB6B5D20A6DC9C /* GTMSessionFetcherLogging.m */,
+				A65BC05DA1122277E055FA1A3EE4AFAF /* GTMSessionFetcherService.h */,
+				AA060057AF151DB56F7677AF4F95B457 /* GTMSessionFetcherService.m */,
+				51D29E10113F59F8B03D62B62AC507C9 /* GTMSessionUploadFetcher.h */,
+				F4566B7D99D538A8B56C58885B5C7AF9 /* GTMSessionUploadFetcher.m */,
+			);
+			name = Core;
+			sourceTree = "<group>";
+		};
+		2E339049816F198EB76DEA4264EF8374 /* iOS */ = {
+			isa = PBXGroup;
+			children = (
+				B4690263E3C2DD3C24DEAC554FFBD486 /* Foundation.framework */,
+				CAFD15069DBFFAF7E7CD48183E2D230C /* Security.framework */,
+			);
+			name = iOS;
+			sourceTree = "<group>";
+		};
+		34BA21F2493AC2BEE7166F17FFF446B4 /* GoogleInterchangeUtilities */ = {
+			isa = PBXGroup;
+			children = (
+				1F82E856F6366BC55E8AA15B58F769A2 /* Frameworks */,
+			);
+			name = GoogleInterchangeUtilities;
+			path = GoogleInterchangeUtilities;
+			sourceTree = "<group>";
+		};
+		3943FEDA5C06ECF21C1E4FD03971709E /* FirebaseDatabase */ = {
+			isa = PBXGroup;
+			children = (
+				ABA129E5F40A1914956201088AE08DA3 /* Frameworks */,
+			);
+			name = FirebaseDatabase;
+			path = FirebaseDatabase;
+			sourceTree = "<group>";
+		};
+		3B867DE8F1D99A2FBD94E56BBFE03622 /* Support Files */ = {
+			isa = PBXGroup;
+			children = (
+				6B344812936B5768866A3C61F687744F /* GTMSessionFetcher.xcconfig */,
+				4DD91002BCF9915312AD20281FD51435 /* GTMSessionFetcher-dummy.m */,
+				5696FC1316CB903A341D34EB9AFB06B4 /* GTMSessionFetcher-prefix.pch */,
+			);
+			name = "Support Files";
+			path = "../Target Support Files/GTMSessionFetcher";
+			sourceTree = "<group>";
+		};
+		3ECD1C145F16F5A5BEAB2F46E2B9381D /* Pods-Task Burner */ = {
+			isa = PBXGroup;
+			children = (
+				3C7420535ACBD3D143B95490196FF34F /* Pods-Task Burner-acknowledgements.markdown */,
+				FF727D42E333859869F3AB7B03C5A46C /* Pods-Task Burner-acknowledgements.plist */,
+				84D81D90A049FA6F1EC648D7C77F549B /* Pods-Task Burner-dummy.m */,
+				E10345C14514E28C3AD064233A3A4D9F /* Pods-Task Burner-frameworks.sh */,
+				DAF48B844D73C0CDD7693B471096C430 /* Pods-Task Burner-resources.sh */,
+				C971B9EA7E7B9214492546F7D4052C0F /* Pods-Task Burner.debug.xcconfig */,
+				3302A115413B703F3744584FED312A14 /* Pods-Task Burner.release.xcconfig */,
+			);
+			name = "Pods-Task Burner";
+			path = "Target Support Files/Pods-Task Burner";
+			sourceTree = "<group>";
+		};
+		433CD3331B6C3787F473C941B61FC68F /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				2E339049816F198EB76DEA4264EF8374 /* iOS */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		560773E1DFF7905574F357ED3595A850 /* Defines */ = {
+			isa = PBXGroup;
+			children = (
+				3EB8DA35765DD5E8F31B2FBF56495D2A /* GTMDefines.h */,
+			);
+			name = Defines;
+			sourceTree = "<group>";
+		};
+		5D5116B919B72D5A776CCCA5A55D56D1 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				1E12D9E778B2314B4E96D753DE05B80B /* FirebaseAnalytics.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		641AECE8A3441FE880D9579EBE42D127 /* NSData+zlib */ = {
+			isa = PBXGroup;
+			children = (
+				F53D6A595711D2D2F72DF8A1C69F4B76 /* GTMNSData+zlib.h */,
+				450D20C8A4B2C00E0E699329C336A410 /* GTMNSData+zlib.m */,
+			);
+			name = "NSData+zlib";
+			sourceTree = "<group>";
+		};
+		67C13782D164C33418A3DC007345EEAF /* FirebaseAuth */ = {
+			isa = PBXGroup;
+			children = (
+				E411536E94FE8F4BA5EA00002396504C /* Frameworks */,
+			);
+			name = FirebaseAuth;
+			path = FirebaseAuth;
+			sourceTree = "<group>";
+		};
+		6F4E97D49905C5A87BF4EDE313450678 /* FirebaseCore */ = {
+			isa = PBXGroup;
+			children = (
+				DE3230BFB229154DF7E393CE076D0793 /* Frameworks */,
+			);
+			name = FirebaseCore;
+			path = FirebaseCore;
+			sourceTree = "<group>";
+		};
+		7C68E5C9EED5495C7D12FDB7C93E2165 /* Pods */ = {
+			isa = PBXGroup;
+			children = (
+				CD39BC08FBFAAEE49168C0CF3BF12D23 /* Firebase */,
+				B7D51504E8AC0BAE4AB9C10D917D45D0 /* FirebaseAnalytics */,
+				67C13782D164C33418A3DC007345EEAF /* FirebaseAuth */,
+				6F4E97D49905C5A87BF4EDE313450678 /* FirebaseCore */,
+				3943FEDA5C06ECF21C1E4FD03971709E /* FirebaseDatabase */,
+				A631107F6BF85505BD6AF2EA4161EDBA /* FirebaseInstanceID */,
+				34BA21F2493AC2BEE7166F17FFF446B4 /* GoogleInterchangeUtilities */,
+				0FEE339796C999F898C7C3F9AD4291A3 /* GoogleSymbolUtilities */,
+				DDCD13879941F5F7855540BCAB02B535 /* GoogleToolboxForMac */,
+				EB3B4C9F23A040955FC08C2735B4A166 /* GTMSessionFetcher */,
+			);
+			name = Pods;
+			sourceTree = "<group>";
+		};
+		7DB346D0F39D3F0E887471402A8071AB = {
+			isa = PBXGroup;
+			children = (
+				93A4A3777CF96A4AAC1D13BA6DCCEA73 /* Podfile */,
+				433CD3331B6C3787F473C941B61FC68F /* Frameworks */,
+				7C68E5C9EED5495C7D12FDB7C93E2165 /* Pods */,
+				899757495517A251C8F12BFC05F2F662 /* Products */,
+				BF0DBC5867069C8A0F9DA76ACA815FE1 /* Targets Support Files */,
+			);
+			sourceTree = "<group>";
+		};
+		899757495517A251C8F12BFC05F2F662 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				01D4834F06DB740C2829D5D6876C60E7 /* libGoogleToolboxForMac.a */,
+				9E8ACF90A25AEB15F1010B7B6E9EC3F8 /* libGTMSessionFetcher.a */,
+				76C5068038AD5399FF8EB3D8A3E6D0F8 /* libPods-Task Burner.a */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		A631107F6BF85505BD6AF2EA4161EDBA /* FirebaseInstanceID */ = {
+			isa = PBXGroup;
+			children = (
+				0AF57663DC977510D58585C2C7095993 /* FIRInstanceID.h */,
+				1ED5EA34C05D3C08A1CBF967F58EB3F3 /* Frameworks */,
+			);
+			name = FirebaseInstanceID;
+			path = FirebaseInstanceID;
+			sourceTree = "<group>";
+		};
+		ABA129E5F40A1914956201088AE08DA3 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				C76746CE34097BBFFE14EDA4648E655E /* FirebaseDatabase.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		AD6ADF88ECAB4A3B956393CC65657758 /* Support Files */ = {
+			isa = PBXGroup;
+			children = (
+				B0BCEB2BE215955E08FBABAC2F342963 /* GoogleToolboxForMac.xcconfig */,
+				ACE77093C121EA932E8AC513F0E9F7CF /* GoogleToolboxForMac-dummy.m */,
+				1681F0B4DDE056E943C58F99F7F8D96E /* GoogleToolboxForMac-prefix.pch */,
+			);
+			name = "Support Files";
+			path = "../Target Support Files/GoogleToolboxForMac";
+			sourceTree = "<group>";
+		};
+		B7D51504E8AC0BAE4AB9C10D917D45D0 /* FirebaseAnalytics */ = {
+			isa = PBXGroup;
+			children = (
+				5D5116B919B72D5A776CCCA5A55D56D1 /* Frameworks */,
+			);
+			name = FirebaseAnalytics;
+			path = FirebaseAnalytics;
+			sourceTree = "<group>";
+		};
+		BF0DBC5867069C8A0F9DA76ACA815FE1 /* Targets Support Files */ = {
+			isa = PBXGroup;
+			children = (
+				3ECD1C145F16F5A5BEAB2F46E2B9381D /* Pods-Task Burner */,
+			);
+			name = "Targets Support Files";
+			sourceTree = "<group>";
+		};
+		CD39BC08FBFAAEE49168C0CF3BF12D23 /* Firebase */ = {
+			isa = PBXGroup;
+			children = (
+				FAA4848E856FF791438A9A3C0E295A17 /* Core */,
+			);
+			name = Firebase;
+			path = Firebase;
+			sourceTree = "<group>";
+		};
+		DDCD13879941F5F7855540BCAB02B535 /* GoogleToolboxForMac */ = {
+			isa = PBXGroup;
+			children = (
+				E8613E68AD5AEDA48D6572140F4C2E64 /* DebugUtils */,
+				560773E1DFF7905574F357ED3595A850 /* Defines */,
+				641AECE8A3441FE880D9579EBE42D127 /* NSData+zlib */,
+				F01B5FDE5AF7D014989E670E22354AB0 /* NSDictionary+URLArguments */,
+				19D2B8153A76EF4EA5D4C72988567FC5 /* NSString+URLArguments */,
+				AD6ADF88ECAB4A3B956393CC65657758 /* Support Files */,
+			);
+			name = GoogleToolboxForMac;
+			path = GoogleToolboxForMac;
+			sourceTree = "<group>";
+		};
+		DE3230BFB229154DF7E393CE076D0793 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				632CA29AC91DB6DF4F279FCBC9EC20D3 /* FirebaseCore.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		E411536E94FE8F4BA5EA00002396504C /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				BDEFD270EB956D87018E680BD7111D50 /* FirebaseAuth.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		E8613E68AD5AEDA48D6572140F4C2E64 /* DebugUtils */ = {
+			isa = PBXGroup;
+			children = (
+				198915C0CA44B0356C9834B46191A039 /* GTMDebugSelectorValidation.h */,
+				AF9AF0A6BF948AD226A8865B09C54090 /* GTMDebugThreadValidation.h */,
+				ECD0F1EFC7009C67FE0D11DB12122952 /* GTMMethodCheck.h */,
+			);
+			name = DebugUtils;
+			sourceTree = "<group>";
+		};
+		EB3B4C9F23A040955FC08C2735B4A166 /* GTMSessionFetcher */ = {
+			isa = PBXGroup;
+			children = (
+				215C9F496CE94E15A70809F1F5273BF1 /* Core */,
+				3B867DE8F1D99A2FBD94E56BBFE03622 /* Support Files */,
+			);
+			name = GTMSessionFetcher;
+			path = GTMSessionFetcher;
+			sourceTree = "<group>";
+		};
+		EE95B9FE529E517EC9845CBD7B603700 /* Frameworks */ = {
+			isa = PBXGroup;
+			children = (
+				DC59A955ADA37DD0F6FDDF181FAF3E77 /* GoogleSymbolUtilities.framework */,
+			);
+			name = Frameworks;
+			sourceTree = "<group>";
+		};
+		F01B5FDE5AF7D014989E670E22354AB0 /* NSDictionary+URLArguments */ = {
+			isa = PBXGroup;
+			children = (
+				79096A79B53D03AD3665115E0DA95A45 /* GTMNSDictionary+URLArguments.h */,
+				76CE7EF4EC993A5A43620E9D17CA2672 /* GTMNSDictionary+URLArguments.m */,
+			);
+			name = "NSDictionary+URLArguments";
+			sourceTree = "<group>";
+		};
+		FAA4848E856FF791438A9A3C0E295A17 /* Core */ = {
+			isa = PBXGroup;
+			children = (
+				3A9F1E2FEAB05086AE95B22A86CB9DFC /* Firebase.h */,
+			);
+			name = Core;
+			sourceTree = "<group>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXHeadersBuildPhase section */
+		0CBA5A14986DAE7D6A473749221AA81F /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				476D901118FCE3506AF5ECEFC743403B /* GTMDebugSelectorValidation.h in Headers */,
+				226B1BFF4E3FC473A1C88F2CFD77C9AF /* GTMDebugThreadValidation.h in Headers */,
+				A46AF96BFE3E00583C3C2AB6C1322D7B /* GTMDefines.h in Headers */,
+				5E255A5B5203BE00C7B9E4D2E0D3BDC7 /* GTMMethodCheck.h in Headers */,
+				26BE741AD59EF185570AC9C853F44FAD /* GTMNSData+zlib.h in Headers */,
+				6C262944569C29D04DFA3C5F21494AAB /* GTMNSDictionary+URLArguments.h in Headers */,
+				E84DEF53F8F01BAF747EB387654EC0AC /* GTMNSString+URLArguments.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		A922FE66E6DEA4BD3090DCEB4580F34E /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				E982A741CDD1A8CC804FC7F20E5C006F /* GTMSessionFetcher.h in Headers */,
+				1235AC549ED1B1EF40635602DCF8B4D5 /* GTMSessionFetcherLogging.h in Headers */,
+				B4B084A9C602985BE7858EA801AD4382 /* GTMSessionFetcherService.h in Headers */,
+				0E6F2758E5743B053E54C51B0D236AF0 /* GTMSessionUploadFetcher.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXHeadersBuildPhase section */
+
+/* Begin PBXNativeTarget section */
+		1E5280EF7C55EA14FF78108514A368E3 /* Pods-Task Burner */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = A59ACE6F9676B20B2B8BEB84FFEFEE31 /* Build configuration list for PBXNativeTarget "Pods-Task Burner" */;
+			buildPhases = (
+				F420568B3452EA879A95D5FCBB393332 /* Sources */,
+				39DAA8001E09064D451C0B69AE13E8EF /* Frameworks */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+				9D56C6408784B28A8DFE97E0EBA85906 /* PBXTargetDependency */,
+				D16A576588AF6A610139B6AB9B910A5A /* PBXTargetDependency */,
+			);
+			name = "Pods-Task Burner";
+			productName = "Pods-Task Burner";
+			productReference = 76C5068038AD5399FF8EB3D8A3E6D0F8 /* libPods-Task Burner.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+		58E7450DB13C5ECCE92D3C0DF7CF0903 /* GoogleToolboxForMac */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 26AE791F404F3732C3335D0EFE25E20A /* Build configuration list for PBXNativeTarget "GoogleToolboxForMac" */;
+			buildPhases = (
+				F86A0216D6948A1D34655DBC29C561FC /* Sources */,
+				E468DEE3816A9E9ED082166AC0F3EAAB /* Frameworks */,
+				0CBA5A14986DAE7D6A473749221AA81F /* Headers */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = GoogleToolboxForMac;
+			productName = GoogleToolboxForMac;
+			productReference = 01D4834F06DB740C2829D5D6876C60E7 /* libGoogleToolboxForMac.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+		DE868725B18AE240E550C5515AE66BC4 /* GTMSessionFetcher */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 4693C211CA1C7318A8B388F1C2D24725 /* Build configuration list for PBXNativeTarget "GTMSessionFetcher" */;
+			buildPhases = (
+				474FE5FB84FE06E59DA34EFCEB7B07B2 /* Sources */,
+				8D2BE8CE5663DF1EA1CF1CC5269C6067 /* Frameworks */,
+				A922FE66E6DEA4BD3090DCEB4580F34E /* Headers */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = GTMSessionFetcher;
+			productName = GTMSessionFetcher;
+			productReference = 9E8ACF90A25AEB15F1010B7B6E9EC3F8 /* libGTMSessionFetcher.a */;
+			productType = "com.apple.product-type.library.static";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		D41D8CD98F00B204E9800998ECF8427E /* Project object */ = {
+			isa = PBXProject;
+			attributes = {
+				LastSwiftUpdateCheck = 0730;
+				LastUpgradeCheck = 0700;
+			};
+			buildConfigurationList = 2D8E8EC45A3A1A1D94AE762CB5028504 /* Build configuration list for PBXProject "Pods" */;
+			compatibilityVersion = "Xcode 3.2";
+			developmentRegion = English;
+			hasScannedForEncodings = 0;
+			knownRegions = (
+				en,
+			);
+			mainGroup = 7DB346D0F39D3F0E887471402A8071AB;
+			productRefGroup = 899757495517A251C8F12BFC05F2F662 /* Products */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				58E7450DB13C5ECCE92D3C0DF7CF0903 /* GoogleToolboxForMac */,
+				DE868725B18AE240E550C5515AE66BC4 /* GTMSessionFetcher */,
+				1E5280EF7C55EA14FF78108514A368E3 /* Pods-Task Burner */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXSourcesBuildPhase section */
+		474FE5FB84FE06E59DA34EFCEB7B07B2 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				74B88A8B5B43AE22CE208F1AF9315336 /* GTMSessionFetcher-dummy.m in Sources */,
+				9B3794E275C6348A291A1E0A52CAF113 /* GTMSessionFetcher.m in Sources */,
+				CDA0F61C3BD605E63D0500A1A0574969 /* GTMSessionFetcherLogging.m in Sources */,
+				9BB31E94CF2D3BEB22EEC2E0D2147C64 /* GTMSessionFetcherService.m in Sources */,
+				522C0FE7197A2D7D3D925ADA58429D05 /* GTMSessionUploadFetcher.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		F420568B3452EA879A95D5FCBB393332 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				2583A3E4525E67AC3D64936F3952D567 /* Pods-Task Burner-dummy.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+		F86A0216D6948A1D34655DBC29C561FC /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				3328D6AA0A6DD5371B63ECAD18718F3F /* GoogleToolboxForMac-dummy.m in Sources */,
+				E071ED04676790AFF262727DB6BC5DE1 /* GTMNSData+zlib.m in Sources */,
+				5353CD4CF7B378621E34EA62C699E40F /* GTMNSDictionary+URLArguments.m in Sources */,
+				ACBF3E2E9A6B3E9FD859BF001F20D694 /* GTMNSString+URLArguments.m in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXTargetDependency section */
+		9D56C6408784B28A8DFE97E0EBA85906 /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			name = GTMSessionFetcher;
+			target = DE868725B18AE240E550C5515AE66BC4 /* GTMSessionFetcher */;
+			targetProxy = 46A250E2AE529E111F158A88D1FA619B /* PBXContainerItemProxy */;
+		};
+		D16A576588AF6A610139B6AB9B910A5A /* PBXTargetDependency */ = {
+			isa = PBXTargetDependency;
+			name = GoogleToolboxForMac;
+			target = 58E7450DB13C5ECCE92D3C0DF7CF0903 /* GoogleToolboxForMac */;
+			targetProxy = 402CF8AFD3F030BFD607E1A1FF3CDDA0 /* PBXContainerItemProxy */;
+		};
+/* End PBXTargetDependency section */
+
+/* Begin XCBuildConfiguration section */
+		059338D4D9216B410FCAE27130A15DED /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = C971B9EA7E7B9214492546F7D4052C0F /* Pods-Task Burner.debug.xcconfig */;
+			buildSettings = {
+				"CODE_SIGN_IDENTITY[sdk=appletvos*]" = "";
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "";
+				"CODE_SIGN_IDENTITY[sdk=watchos*]" = "";
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 10.0;
+				MACH_O_TYPE = staticlib;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				OTHER_LDFLAGS = "";
+				OTHER_LIBTOOLFLAGS = "";
+				PODS_ROOT = "$(SRCROOT)";
+				PRODUCT_BUNDLE_IDENTIFIER = "org.cocoapods.${PRODUCT_NAME:rfc1034identifier}";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+			};
+			name = Debug;
+		};
+		12914D756594D15C6F2CA12FE5F89F1B /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				CODE_SIGNING_REQUIRED = NO;
+				COPY_PHASE_STRIP = NO;
+				ENABLE_TESTABILITY = YES;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"POD_CONFIGURATION_DEBUG=1",
+					"DEBUG=1",
+					"$(inherited)",
+				);
+				GCC_SYMBOLS_PRIVATE_EXTERN = NO;
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 10.0;
+				ONLY_ACTIVE_ARCH = YES;
+				PROVISIONING_PROFILE_SPECIFIER = NO_SIGNING/;
+				STRIP_INSTALLED_PRODUCT = NO;
+				SYMROOT = "${SRCROOT}/../build";
+			};
+			name = Debug;
+		};
+		280F1391035F25CB3FC30138CEEE39B4 /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 3302A115413B703F3744584FED312A14 /* Pods-Task Burner.release.xcconfig */;
+			buildSettings = {
+				"CODE_SIGN_IDENTITY[sdk=appletvos*]" = "";
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "";
+				"CODE_SIGN_IDENTITY[sdk=watchos*]" = "";
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 10.0;
+				MACH_O_TYPE = staticlib;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				OTHER_LDFLAGS = "";
+				OTHER_LIBTOOLFLAGS = "";
+				PODS_ROOT = "$(SRCROOT)";
+				PRODUCT_BUNDLE_IDENTIFIER = "org.cocoapods.${PRODUCT_NAME:rfc1034identifier}";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+			};
+			name = Release;
+		};
+		2F5F5B61233D182FE923F37462D6E73B /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = B0BCEB2BE215955E08FBABAC2F342963 /* GoogleToolboxForMac.xcconfig */;
+			buildSettings = {
+				"CODE_SIGN_IDENTITY[sdk=appletvos*]" = "";
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "";
+				"CODE_SIGN_IDENTITY[sdk=watchos*]" = "";
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_PREFIX_HEADER = "Target Support Files/GoogleToolboxForMac/GoogleToolboxForMac-prefix.pch";
+				IPHONEOS_DEPLOYMENT_TARGET = 5.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				OTHER_LDFLAGS = "";
+				OTHER_LIBTOOLFLAGS = "";
+				PRIVATE_HEADERS_FOLDER_PATH = "";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PUBLIC_HEADERS_FOLDER_PATH = "";
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+				SWIFT_VERSION = 3.0;
+			};
+			name = Release;
+		};
+		3E15E1221F5F51D737D557DF33F26CE7 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = B0BCEB2BE215955E08FBABAC2F342963 /* GoogleToolboxForMac.xcconfig */;
+			buildSettings = {
+				"CODE_SIGN_IDENTITY[sdk=appletvos*]" = "";
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "";
+				"CODE_SIGN_IDENTITY[sdk=watchos*]" = "";
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_PREFIX_HEADER = "Target Support Files/GoogleToolboxForMac/GoogleToolboxForMac-prefix.pch";
+				IPHONEOS_DEPLOYMENT_TARGET = 5.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				OTHER_LDFLAGS = "";
+				OTHER_LIBTOOLFLAGS = "";
+				PRIVATE_HEADERS_FOLDER_PATH = "";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PUBLIC_HEADERS_FOLDER_PATH = "";
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+				SWIFT_VERSION = 3.0;
+			};
+			name = Debug;
+		};
+		6089EF5AAE5528CF09E8655B284A438E /* Release */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 6B344812936B5768866A3C61F687744F /* GTMSessionFetcher.xcconfig */;
+			buildSettings = {
+				"CODE_SIGN_IDENTITY[sdk=appletvos*]" = "";
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "";
+				"CODE_SIGN_IDENTITY[sdk=watchos*]" = "";
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_PREFIX_HEADER = "Target Support Files/GTMSessionFetcher/GTMSessionFetcher-prefix.pch";
+				IPHONEOS_DEPLOYMENT_TARGET = 7.0;
+				MTL_ENABLE_DEBUG_INFO = NO;
+				OTHER_LDFLAGS = "";
+				OTHER_LIBTOOLFLAGS = "";
+				PRIVATE_HEADERS_FOLDER_PATH = "";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PUBLIC_HEADERS_FOLDER_PATH = "";
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+				SWIFT_VERSION = 3.0;
+			};
+			name = Release;
+		};
+		85750C6A2D9EFD780B5CD014850783CA /* Debug */ = {
+			isa = XCBuildConfiguration;
+			baseConfigurationReference = 6B344812936B5768866A3C61F687744F /* GTMSessionFetcher.xcconfig */;
+			buildSettings = {
+				"CODE_SIGN_IDENTITY[sdk=appletvos*]" = "";
+				"CODE_SIGN_IDENTITY[sdk=iphoneos*]" = "";
+				"CODE_SIGN_IDENTITY[sdk=watchos*]" = "";
+				DEBUG_INFORMATION_FORMAT = dwarf;
+				ENABLE_STRICT_OBJC_MSGSEND = YES;
+				GCC_NO_COMMON_BLOCKS = YES;
+				GCC_PREFIX_HEADER = "Target Support Files/GTMSessionFetcher/GTMSessionFetcher-prefix.pch";
+				IPHONEOS_DEPLOYMENT_TARGET = 7.0;
+				MTL_ENABLE_DEBUG_INFO = YES;
+				OTHER_LDFLAGS = "";
+				OTHER_LIBTOOLFLAGS = "";
+				PRIVATE_HEADERS_FOLDER_PATH = "";
+				PRODUCT_NAME = "$(TARGET_NAME)";
+				PUBLIC_HEADERS_FOLDER_PATH = "";
+				SDKROOT = iphoneos;
+				SKIP_INSTALL = YES;
+				SWIFT_VERSION = 3.0;
+			};
+			name = Debug;
+		};
+		E72E7977875C2D251FC62736BBDDC389 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ALWAYS_SEARCH_USER_PATHS = NO;
+				CLANG_ANALYZER_NONNULL = YES;
+				CLANG_CXX_LANGUAGE_STANDARD = "gnu++0x";
+				CLANG_CXX_LIBRARY = "libc++";
+				CLANG_ENABLE_MODULES = YES;
+				CLANG_ENABLE_OBJC_ARC = YES;
+				CLANG_WARN_BOOL_CONVERSION = YES;
+				CLANG_WARN_CONSTANT_CONVERSION = YES;
+				CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES;
+				CLANG_WARN_EMPTY_BODY = YES;
+				CLANG_WARN_ENUM_CONVERSION = YES;
+				CLANG_WARN_INT_CONVERSION = YES;
+				CLANG_WARN_OBJC_ROOT_CLASS = YES;
+				CLANG_WARN_UNREACHABLE_CODE = YES;
+				CLANG_WARN__DUPLICATE_METHOD_MATCH = YES;
+				CODE_SIGNING_REQUIRED = NO;
+				COPY_PHASE_STRIP = YES;
+				ENABLE_NS_ASSERTIONS = NO;
+				GCC_C_LANGUAGE_STANDARD = gnu99;
+				GCC_PREPROCESSOR_DEFINITIONS = (
+					"POD_CONFIGURATION_RELEASE=1",
+					"$(inherited)",
+				);
+				GCC_WARN_64_TO_32_BIT_CONVERSION = YES;
+				GCC_WARN_ABOUT_RETURN_TYPE = YES;
+				GCC_WARN_UNDECLARED_SELECTOR = YES;
+				GCC_WARN_UNINITIALIZED_AUTOS = YES;
+				GCC_WARN_UNUSED_FUNCTION = YES;
+				GCC_WARN_UNUSED_VARIABLE = YES;
+				IPHONEOS_DEPLOYMENT_TARGET = 10.0;
+				PROVISIONING_PROFILE_SPECIFIER = NO_SIGNING/;
+				STRIP_INSTALLED_PRODUCT = NO;
+				SYMROOT = "${SRCROOT}/../build";
+				VALIDATE_PRODUCT = YES;
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		26AE791F404F3732C3335D0EFE25E20A /* Build configuration list for PBXNativeTarget "GoogleToolboxForMac" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				3E15E1221F5F51D737D557DF33F26CE7 /* Debug */,
+				2F5F5B61233D182FE923F37462D6E73B /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		2D8E8EC45A3A1A1D94AE762CB5028504 /* Build configuration list for PBXProject "Pods" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				12914D756594D15C6F2CA12FE5F89F1B /* Debug */,
+				E72E7977875C2D251FC62736BBDDC389 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		4693C211CA1C7318A8B388F1C2D24725 /* Build configuration list for PBXNativeTarget "GTMSessionFetcher" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				85750C6A2D9EFD780B5CD014850783CA /* Debug */,
+				6089EF5AAE5528CF09E8655B284A438E /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+		A59ACE6F9676B20B2B8BEB84FFEFEE31 /* Build configuration list for PBXNativeTarget "Pods-Task Burner" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				059338D4D9216B410FCAE27130A15DED /* Debug */,
+				280F1391035F25CB3FC30138CEEE39B4 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Release;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = D41D8CD98F00B204E9800998ECF8427E /* Project object */;
+}

Code Burner/Pods/Pods.xcodeproj/xcuserdata/alexanderdavis.xcuserdatad/xcschemes/GTMSessionFetcher.xcscheme

@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0830"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "DE868725B18AE240E550C5515AE66BC4"
+               BuildableName = "libGTMSessionFetcher.a"
+               BlueprintName = "GTMSessionFetcher"
+               ReferencedContainer = "container:Pods.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+      </Testables>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "DE868725B18AE240E550C5515AE66BC4"
+            BuildableName = "libGTMSessionFetcher.a"
+            BlueprintName = "GTMSessionFetcher"
+            ReferencedContainer = "container:Pods.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "DE868725B18AE240E550C5515AE66BC4"
+            BuildableName = "libGTMSessionFetcher.a"
+            BlueprintName = "GTMSessionFetcher"
+            ReferencedContainer = "container:Pods.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

Code Burner/Pods/Pods.xcodeproj/xcuserdata/alexanderdavis.xcuserdatad/xcschemes/GoogleToolboxForMac.xcscheme

@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0830"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "58E7450DB13C5ECCE92D3C0DF7CF0903"
+               BuildableName = "libGoogleToolboxForMac.a"
+               BlueprintName = "GoogleToolboxForMac"
+               ReferencedContainer = "container:Pods.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+      </Testables>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "58E7450DB13C5ECCE92D3C0DF7CF0903"
+            BuildableName = "libGoogleToolboxForMac.a"
+            BlueprintName = "GoogleToolboxForMac"
+            ReferencedContainer = "container:Pods.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "58E7450DB13C5ECCE92D3C0DF7CF0903"
+            BuildableName = "libGoogleToolboxForMac.a"
+            BlueprintName = "GoogleToolboxForMac"
+            ReferencedContainer = "container:Pods.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

Code Burner/Pods/Pods.xcodeproj/xcuserdata/alexanderdavis.xcuserdatad/xcschemes/Pods-Task Burner.xcscheme

@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0830"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "1E5280EF7C55EA14FF78108514A368E3"
+               BuildableName = "libPods-Task Burner.a"
+               BlueprintName = "Pods-Task Burner"
+               ReferencedContainer = "container:Pods.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+      </Testables>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "1E5280EF7C55EA14FF78108514A368E3"
+            BuildableName = "libPods-Task Burner.a"
+            BlueprintName = "Pods-Task Burner"
+            ReferencedContainer = "container:Pods.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "1E5280EF7C55EA14FF78108514A368E3"
+            BuildableName = "libPods-Task Burner.a"
+            BlueprintName = "Pods-Task Burner"
+            ReferencedContainer = "container:Pods.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

Code Burner/Pods/Pods.xcodeproj/xcuserdata/alexanderdavis.xcuserdatad/xcschemes/xcschememanagement.plist

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>SchemeUserState</key>
+	<dict>
+		<key>GTMSessionFetcher.xcscheme</key>
+		<dict>
+			<key>orderHint</key>
+			<integer>2</integer>
+		</dict>
+		<key>GoogleToolboxForMac.xcscheme</key>
+		<dict>
+			<key>orderHint</key>
+			<integer>1</integer>
+		</dict>
+		<key>Pods-Task Burner.xcscheme</key>
+		<dict>
+			<key>orderHint</key>
+			<integer>3</integer>
+		</dict>
+	</dict>
+	<key>SuppressBuildableAutocreation</key>
+	<dict>
+		<key>1E5280EF7C55EA14FF78108514A368E3</key>
+		<dict>
+			<key>primary</key>
+			<true/>
+		</dict>
+		<key>58E7450DB13C5ECCE92D3C0DF7CF0903</key>
+		<dict>
+			<key>primary</key>
+			<true/>
+		</dict>
+		<key>DE868725B18AE240E550C5515AE66BC4</key>
+		<dict>
+			<key>primary</key>
+			<true/>
+		</dict>
+	</dict>
+</dict>
+</plist>

Code Burner/Pods/Pods.xcodeproj/xcuserdata/andrei.xcuserdatad/xcschemes/GTMSessionFetcher.xcscheme

@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0700"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForAnalyzing = "YES"
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES">
+            <BuildableReference
+               BuildableIdentifier = 'primary'
+               BlueprintIdentifier = 'DE868725B18AE240E550C5515AE66BC4'
+               BlueprintName = 'GTMSessionFetcher'
+               ReferencedContainer = 'container:Pods.xcodeproj'
+               BuildableName = 'libGTMSessionFetcher.a'>
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      buildConfiguration = "Debug">
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </TestAction>
+   <LaunchAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      buildConfiguration = "Debug"
+      allowLocationSimulation = "YES">
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES"
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

Code Burner/Pods/Pods.xcodeproj/xcuserdata/andrei.xcuserdatad/xcschemes/GoogleToolboxForMac.xcscheme

@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0700"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForAnalyzing = "YES"
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES">
+            <BuildableReference
+               BuildableIdentifier = 'primary'
+               BlueprintIdentifier = '58E7450DB13C5ECCE92D3C0DF7CF0903'
+               BlueprintName = 'GoogleToolboxForMac'
+               ReferencedContainer = 'container:Pods.xcodeproj'
+               BuildableName = 'libGoogleToolboxForMac.a'>
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      buildConfiguration = "Debug">
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </TestAction>
+   <LaunchAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      buildConfiguration = "Debug"
+      allowLocationSimulation = "YES">
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES"
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

Code Burner/Pods/Pods.xcodeproj/xcuserdata/andrei.xcuserdatad/xcschemes/Pods-Task Burner.xcscheme

@@ -0,0 +1,60 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0700"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForAnalyzing = "YES"
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES">
+            <BuildableReference
+               BuildableIdentifier = 'primary'
+               BlueprintIdentifier = '1E5280EF7C55EA14FF78108514A368E3'
+               BlueprintName = 'Pods-Task Burner'
+               ReferencedContainer = 'container:Pods.xcodeproj'
+               BuildableName = 'libPods-Task Burner.a'>
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      buildConfiguration = "Debug">
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </TestAction>
+   <LaunchAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      buildConfiguration = "Debug"
+      allowLocationSimulation = "YES">
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES"
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>

Code Burner/Pods/Pods.xcodeproj/xcuserdata/andrei.xcuserdatad/xcschemes/xcschememanagement.plist

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>SchemeUserState</key>
+	<dict>
+		<key>GTMSessionFetcher.xcscheme</key>
+		<dict>
+			<key>isShown</key>
+			<false/>
+		</dict>
+		<key>GoogleToolboxForMac.xcscheme</key>
+		<dict>
+			<key>isShown</key>
+			<false/>
+		</dict>
+		<key>Pods-Task Burner.xcscheme</key>
+		<dict>
+			<key>isShown</key>
+			<false/>
+		</dict>
+	</dict>
+	<key>SuppressBuildableAutocreation</key>
+	<dict>
+		<key>1E5280EF7C55EA14FF78108514A368E3</key>
+		<dict>
+			<key>primary</key>
+			<true/>
+		</dict>
+		<key>58E7450DB13C5ECCE92D3C0DF7CF0903</key>
+		<dict>
+			<key>primary</key>
+			<true/>
+		</dict>
+		<key>DE868725B18AE240E550C5515AE66BC4</key>
+		<dict>
+			<key>primary</key>
+			<true/>
+		</dict>
+	</dict>
+</dict>
+</plist>

Code Burner/Pods/Target Support Files/GTMSessionFetcher/GTMSessionFetcher-dummy.m

@@ -0,0 +1,5 @@
+#import <Foundation/Foundation.h>
+@interface PodsDummy_GTMSessionFetcher : NSObject
+@end
+@implementation PodsDummy_GTMSessionFetcher
+@end

Code Burner/Pods/Target Support Files/GTMSessionFetcher/GTMSessionFetcher-prefix.pch

@@ -0,0 +1,4 @@
+#ifdef __OBJC__
+#import <UIKit/UIKit.h>
+#endif
+

Code Burner/Pods/Target Support Files/GTMSessionFetcher/GTMSessionFetcher.xcconfig

@@ -0,0 +1,9 @@
+CONFIGURATION_BUILD_DIR = $PODS_CONFIGURATION_BUILD_DIR/GTMSessionFetcher
+GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
+HEADER_SEARCH_PATHS = "${PODS_ROOT}/Headers/Private" "${PODS_ROOT}/Headers/Private/GTMSessionFetcher" "${PODS_ROOT}/Headers/Public" "${PODS_ROOT}/Headers/Public/Firebase" "${PODS_ROOT}/Headers/Public/FirebaseAnalytics" "${PODS_ROOT}/Headers/Public/FirebaseAuth" "${PODS_ROOT}/Headers/Public/FirebaseCore" "${PODS_ROOT}/Headers/Public/FirebaseDatabase" "${PODS_ROOT}/Headers/Public/FirebaseInstanceID" "${PODS_ROOT}/Headers/Public/GTMSessionFetcher" "${PODS_ROOT}/Headers/Public/GoogleInterchangeUtilities" "${PODS_ROOT}/Headers/Public/GoogleSymbolUtilities" "${PODS_ROOT}/Headers/Public/GoogleToolboxForMac"
+OTHER_LDFLAGS = -framework "Security"
+PODS_BUILD_DIR = $BUILD_DIR
+PODS_CONFIGURATION_BUILD_DIR = $PODS_BUILD_DIR/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
+PODS_ROOT = ${SRCROOT}
+PRODUCT_BUNDLE_IDENTIFIER = org.cocoapods.${PRODUCT_NAME:rfc1034identifier}
+SKIP_INSTALL = YES

Code Burner/Pods/Target Support Files/GoogleToolboxForMac/GoogleToolboxForMac-dummy.m

@@ -0,0 +1,5 @@
+#import <Foundation/Foundation.h>
+@interface PodsDummy_GoogleToolboxForMac : NSObject
+@end
+@implementation PodsDummy_GoogleToolboxForMac
+@end

Code Burner/Pods/Target Support Files/GoogleToolboxForMac/GoogleToolboxForMac-prefix.pch

@@ -0,0 +1,4 @@
+#ifdef __OBJC__
+#import <UIKit/UIKit.h>
+#endif
+

Code Burner/Pods/Target Support Files/GoogleToolboxForMac/GoogleToolboxForMac.xcconfig

@@ -0,0 +1,9 @@
+CONFIGURATION_BUILD_DIR = $PODS_CONFIGURATION_BUILD_DIR/GoogleToolboxForMac
+GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
+HEADER_SEARCH_PATHS = "${PODS_ROOT}/Headers/Private" "${PODS_ROOT}/Headers/Private/GoogleToolboxForMac" "${PODS_ROOT}/Headers/Public" "${PODS_ROOT}/Headers/Public/Firebase" "${PODS_ROOT}/Headers/Public/FirebaseAnalytics" "${PODS_ROOT}/Headers/Public/FirebaseAuth" "${PODS_ROOT}/Headers/Public/FirebaseCore" "${PODS_ROOT}/Headers/Public/FirebaseDatabase" "${PODS_ROOT}/Headers/Public/FirebaseInstanceID" "${PODS_ROOT}/Headers/Public/GTMSessionFetcher" "${PODS_ROOT}/Headers/Public/GoogleInterchangeUtilities" "${PODS_ROOT}/Headers/Public/GoogleSymbolUtilities" "${PODS_ROOT}/Headers/Public/GoogleToolboxForMac"
+OTHER_LDFLAGS = -l"z"
+PODS_BUILD_DIR = $BUILD_DIR
+PODS_CONFIGURATION_BUILD_DIR = $PODS_BUILD_DIR/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
+PODS_ROOT = ${SRCROOT}
+PRODUCT_BUNDLE_IDENTIFIER = org.cocoapods.${PRODUCT_NAME:rfc1034identifier}
+SKIP_INSTALL = YES

Code Burner/Pods/Target Support Files/Pods-Task Burner/Pods-Task Burner-acknowledgements.markdown

@@ -0,0 +1,447 @@
+# Acknowledgements
+This application makes use of the following third party libraries:
+
+## Firebase
+
+Copyright 2016 Google
+
+## FirebaseAnalytics
+
+Copyright 2016 Google
+
+## FirebaseAuth
+
+Copyright 2016 Google
+
+## FirebaseCore
+
+Copyright 2016 Google
+
+## FirebaseDatabase
+
+Copyright 2016 Google
+
+## FirebaseInstanceID
+
+Copyright 2016 Google
+
+## GTMSessionFetcher
+
+
+                                 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.
+
+
+## GoogleInterchangeUtilities
+
+Copyright 2016 Google
+
+## GoogleSymbolUtilities
+
+Copyright 2016 Google
+
+## GoogleToolboxForMac
+
+
+                                 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.
+
+Generated by CocoaPods - https://cocoapods.org

Code Burner/Pods/Target Support Files/Pods-Task Burner/Pods-Task Burner-acknowledgements.plist

@@ -0,0 +1,533 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>PreferenceSpecifiers</key>
+	<array>
+		<dict>
+			<key>FooterText</key>
+			<string>This application makes use of the following third party libraries:</string>
+			<key>Title</key>
+			<string>Acknowledgements</string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+		<dict>
+			<key>FooterText</key>
+			<string>Copyright 2016 Google</string>
+			<key>License</key>
+			<string>Copyright</string>
+			<key>Title</key>
+			<string>Firebase</string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+		<dict>
+			<key>FooterText</key>
+			<string>Copyright 2016 Google</string>
+			<key>License</key>
+			<string>Copyright</string>
+			<key>Title</key>
+			<string>FirebaseAnalytics</string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+		<dict>
+			<key>FooterText</key>
+			<string>Copyright 2016 Google</string>
+			<key>License</key>
+			<string>Copyright</string>
+			<key>Title</key>
+			<string>FirebaseAuth</string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+		<dict>
+			<key>FooterText</key>
+			<string>Copyright 2016 Google</string>
+			<key>License</key>
+			<string>Copyright</string>
+			<key>Title</key>
+			<string>FirebaseCore</string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+		<dict>
+			<key>FooterText</key>
+			<string>Copyright 2016 Google</string>
+			<key>License</key>
+			<string>Copyright</string>
+			<key>Title</key>
+			<string>FirebaseDatabase</string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+		<dict>
+			<key>FooterText</key>
+			<string>Copyright 2016 Google</string>
+			<key>License</key>
+			<string>Copyright</string>
+			<key>Title</key>
+			<string>FirebaseInstanceID</string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+		<dict>
+			<key>FooterText</key>
+			<string>
+                                 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.
+</string>
+			<key>License</key>
+			<string>Apache</string>
+			<key>Title</key>
+			<string>GTMSessionFetcher</string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+		<dict>
+			<key>FooterText</key>
+			<string>Copyright 2016 Google</string>
+			<key>License</key>
+			<string>Copyright</string>
+			<key>Title</key>
+			<string>GoogleInterchangeUtilities</string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+		<dict>
+			<key>FooterText</key>
+			<string>Copyright 2016 Google</string>
+			<key>License</key>
+			<string>Copyright</string>
+			<key>Title</key>
+			<string>GoogleSymbolUtilities</string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+		<dict>
+			<key>FooterText</key>
+			<string>
+                                 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.
+</string>
+			<key>License</key>
+			<string>Apache</string>
+			<key>Title</key>
+			<string>GoogleToolboxForMac</string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+		<dict>
+			<key>FooterText</key>
+			<string>Generated by CocoaPods - https://cocoapods.org</string>
+			<key>Title</key>
+			<string></string>
+			<key>Type</key>
+			<string>PSGroupSpecifier</string>
+		</dict>
+	</array>
+	<key>StringsTable</key>
+	<string>Acknowledgements</string>
+	<key>Title</key>
+	<string>Acknowledgements</string>
+</dict>
+</plist>

Code Burner/Pods/Target Support Files/Pods-Task Burner/Pods-Task Burner-dummy.m

@@ -0,0 +1,5 @@
+#import <Foundation/Foundation.h>
+@interface PodsDummy_Pods_Task_Burner : NSObject
+@end
+@implementation PodsDummy_Pods_Task_Burner
+@end

Code Burner/Pods/Target Support Files/Pods-Task Burner/Pods-Task Burner-frameworks.sh

@@ -0,0 +1,84 @@
+#!/bin/sh
+set -e
+
+echo "mkdir -p ${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
+mkdir -p "${CONFIGURATION_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
+
+SWIFT_STDLIB_PATH="${DT_TOOLCHAIN_DIR}/usr/lib/swift/${PLATFORM_NAME}"
+
+install_framework()
+{
+  if [ -r "${BUILT_PRODUCTS_DIR}/$1" ]; then
+    local source="${BUILT_PRODUCTS_DIR}/$1"
+  elif [ -r "${BUILT_PRODUCTS_DIR}/$(basename "$1")" ]; then
+    local source="${BUILT_PRODUCTS_DIR}/$(basename "$1")"
+  elif [ -r "$1" ]; then
+    local source="$1"
+  fi
+
+  local destination="${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
+
+  if [ -L "${source}" ]; then
+      echo "Symlinked..."
+      source="$(readlink "${source}")"
+  fi
+
+  # use filter instead of exclude so missing patterns dont' throw errors
+  echo "rsync -av --filter \"- CVS/\" --filter \"- .svn/\" --filter \"- .git/\" --filter \"- .hg/\" --filter \"- Headers\" --filter \"- PrivateHeaders\" --filter \"- Modules\" \"${source}\" \"${destination}\""
+  rsync -av --filter "- CVS/" --filter "- .svn/" --filter "- .git/" --filter "- .hg/" --filter "- Headers" --filter "- PrivateHeaders" --filter "- Modules" "${source}" "${destination}"
+
+  local basename
+  basename="$(basename -s .framework "$1")"
+  binary="${destination}/${basename}.framework/${basename}"
+  if ! [ -r "$binary" ]; then
+    binary="${destination}/${basename}"
+  fi
+
+  # Strip invalid architectures so "fat" simulator / device frameworks work on device
+  if [[ "$(file "$binary")" == *"dynamically linked shared library"* ]]; then
+    strip_invalid_archs "$binary"
+  fi
+
+  # Resign the code if required by the build settings to avoid unstable apps
+  code_sign_if_enabled "${destination}/$(basename "$1")"
+
+  # Embed linked Swift runtime libraries. No longer necessary as of Xcode 7.
+  if [ "${XCODE_VERSION_MAJOR}" -lt 7 ]; then
+    local swift_runtime_libs
+    swift_runtime_libs=$(xcrun otool -LX "$binary" | grep --color=never @rpath/libswift | sed -E s/@rpath\\/\(.+dylib\).*/\\1/g | uniq -u  && exit ${PIPESTATUS[0]})
+    for lib in $swift_runtime_libs; do
+      echo "rsync -auv \"${SWIFT_STDLIB_PATH}/${lib}\" \"${destination}\""
+      rsync -auv "${SWIFT_STDLIB_PATH}/${lib}" "${destination}"
+      code_sign_if_enabled "${destination}/${lib}"
+    done
+  fi
+}
+
+# Signs a framework with the provided identity
+code_sign_if_enabled() {
+  if [ -n "${EXPANDED_CODE_SIGN_IDENTITY}" -a "${CODE_SIGNING_REQUIRED}" != "NO" -a "${CODE_SIGNING_ALLOWED}" != "NO" ]; then
+    # Use the current code_sign_identitiy
+    echo "Code Signing $1 with Identity ${EXPANDED_CODE_SIGN_IDENTITY_NAME}"
+    echo "/usr/bin/codesign --force --sign ${EXPANDED_CODE_SIGN_IDENTITY} ${OTHER_CODE_SIGN_FLAGS} --preserve-metadata=identifier,entitlements \"$1\""
+    /usr/bin/codesign --force --sign ${EXPANDED_CODE_SIGN_IDENTITY} ${OTHER_CODE_SIGN_FLAGS} --preserve-metadata=identifier,entitlements "$1"
+  fi
+}
+
+# Strip invalid architectures
+strip_invalid_archs() {
+  binary="$1"
+  # Get architectures for current file
+  archs="$(lipo -info "$binary" | rev | cut -d ':' -f1 | rev)"
+  stripped=""
+  for arch in $archs; do
+    if ! [[ "${VALID_ARCHS}" == *"$arch"* ]]; then
+      # Strip non-valid architectures in-place
+      lipo -remove "$arch" -output "$binary" "$binary" || exit 1
+      stripped="$stripped $arch"
+    fi
+  done
+  if [[ "$stripped" ]]; then
+    echo "Stripped $binary of architectures:$stripped"
+  fi
+}
+

Code Burner/Pods/Target Support Files/Pods-Task Burner/Pods-Task Burner-resources.sh

@@ -0,0 +1,96 @@
+#!/bin/sh
+set -e
+
+mkdir -p "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
+
+RESOURCES_TO_COPY=${PODS_ROOT}/resources-to-copy-${TARGETNAME}.txt
+> "$RESOURCES_TO_COPY"
+
+XCASSET_FILES=()
+
+case "${TARGETED_DEVICE_FAMILY}" in
+  1,2)
+    TARGET_DEVICE_ARGS="--target-device ipad --target-device iphone"
+    ;;
+  1)
+    TARGET_DEVICE_ARGS="--target-device iphone"
+    ;;
+  2)
+    TARGET_DEVICE_ARGS="--target-device ipad"
+    ;;
+  *)
+    TARGET_DEVICE_ARGS="--target-device mac"
+    ;;
+esac
+
+install_resource()
+{
+  if [[ "$1" = /* ]] ; then
+    RESOURCE_PATH="$1"
+  else
+    RESOURCE_PATH="${PODS_ROOT}/$1"
+  fi
+  if [[ ! -e "$RESOURCE_PATH" ]] ; then
+    cat << EOM
+error: Resource "$RESOURCE_PATH" not found. Run 'pod install' to update the copy resources script.
+EOM
+    exit 1
+  fi
+  case $RESOURCE_PATH in
+    *.storyboard)
+      echo "ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile ${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \"$RESOURCE_PATH\" .storyboard`.storyboardc $RESOURCE_PATH --sdk ${SDKROOT} ${TARGET_DEVICE_ARGS}"
+      ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \"$RESOURCE_PATH\" .storyboard`.storyboardc" "$RESOURCE_PATH" --sdk "${SDKROOT}" ${TARGET_DEVICE_ARGS}
+      ;;
+    *.xib)
+      echo "ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile ${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \"$RESOURCE_PATH\" .xib`.nib $RESOURCE_PATH --sdk ${SDKROOT} ${TARGET_DEVICE_ARGS}"
+      ibtool --reference-external-strings-file --errors --warnings --notices --minimum-deployment-target ${!DEPLOYMENT_TARGET_SETTING_NAME} --output-format human-readable-text --compile "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename \"$RESOURCE_PATH\" .xib`.nib" "$RESOURCE_PATH" --sdk "${SDKROOT}" ${TARGET_DEVICE_ARGS}
+      ;;
+    *.framework)
+      echo "mkdir -p ${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
+      mkdir -p "${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
+      echo "rsync -av $RESOURCE_PATH ${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
+      rsync -av "$RESOURCE_PATH" "${TARGET_BUILD_DIR}/${FRAMEWORKS_FOLDER_PATH}"
+      ;;
+    *.xcdatamodel)
+      echo "xcrun momc \"$RESOURCE_PATH\" \"${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename "$RESOURCE_PATH"`.mom\""
+      xcrun momc "$RESOURCE_PATH" "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename "$RESOURCE_PATH" .xcdatamodel`.mom"
+      ;;
+    *.xcdatamodeld)
+      echo "xcrun momc \"$RESOURCE_PATH\" \"${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename "$RESOURCE_PATH" .xcdatamodeld`.momd\""
+      xcrun momc "$RESOURCE_PATH" "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename "$RESOURCE_PATH" .xcdatamodeld`.momd"
+      ;;
+    *.xcmappingmodel)
+      echo "xcrun mapc \"$RESOURCE_PATH\" \"${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename "$RESOURCE_PATH" .xcmappingmodel`.cdm\""
+      xcrun mapc "$RESOURCE_PATH" "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}/`basename "$RESOURCE_PATH" .xcmappingmodel`.cdm"
+      ;;
+    *.xcassets)
+      ABSOLUTE_XCASSET_FILE="$RESOURCE_PATH"
+      XCASSET_FILES+=("$ABSOLUTE_XCASSET_FILE")
+      ;;
+    *)
+      echo "$RESOURCE_PATH"
+      echo "$RESOURCE_PATH" >> "$RESOURCES_TO_COPY"
+      ;;
+  esac
+}
+
+mkdir -p "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
+rsync -avr --copy-links --no-relative --exclude '*/.svn/*' --files-from="$RESOURCES_TO_COPY" / "${TARGET_BUILD_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
+if [[ "${ACTION}" == "install" ]] && [[ "${SKIP_INSTALL}" == "NO" ]]; then
+  mkdir -p "${INSTALL_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
+  rsync -avr --copy-links --no-relative --exclude '*/.svn/*' --files-from="$RESOURCES_TO_COPY" / "${INSTALL_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
+fi
+rm -f "$RESOURCES_TO_COPY"
+
+if [[ -n "${WRAPPER_EXTENSION}" ]] && [ "`xcrun --find actool`" ] && [ -n "$XCASSET_FILES" ]
+then
+  # Find all other xcassets (this unfortunately includes those of path pods and other targets).
+  OTHER_XCASSETS=$(find "$PWD" -iname "*.xcassets" -type d)
+  while read line; do
+    if [[ $line != "${PODS_ROOT}*" ]]; then
+      XCASSET_FILES+=("$line")
+    fi
+  done <<<"$OTHER_XCASSETS"
+
+  printf "%s\0" "${XCASSET_FILES[@]}" | xargs -0 xcrun actool --output-format human-readable-text --notices --warnings --platform "${PLATFORM_NAME}" --minimum-deployment-target "${!DEPLOYMENT_TARGET_SETTING_NAME}" ${TARGET_DEVICE_ARGS} --compress-pngs --compile "${BUILT_PRODUCTS_DIR}/${UNLOCALIZED_RESOURCES_FOLDER_PATH}"
+fi

Code Burner/Pods/Target Support Files/Pods-Task Burner/Pods-Task Burner.debug.xcconfig

@@ -0,0 +1,10 @@
+ALWAYS_EMBED_SWIFT_STANDARD_LIBRARIES = NO
+FRAMEWORK_SEARCH_PATHS = $(inherited) "${PODS_ROOT}/FirebaseAnalytics/Frameworks/frameworks" "${PODS_ROOT}/FirebaseAuth/Frameworks/frameworks" "${PODS_ROOT}/FirebaseCore/Frameworks/frameworks" "${PODS_ROOT}/FirebaseDatabase/Frameworks" "${PODS_ROOT}/FirebaseInstanceID/Frameworks/frameworks" "${PODS_ROOT}/GoogleInterchangeUtilities/Frameworks/frameworks" "${PODS_ROOT}/GoogleSymbolUtilities/Frameworks/frameworks"
+GCC_PREPROCESSOR_DEFINITIONS = $(inherited) COCOAPODS=1
+HEADER_SEARCH_PATHS = $(inherited) ${PODS_ROOT}/Firebase/Core/Sources $(inherited) "${PODS_ROOT}/Headers/Public" "${PODS_ROOT}/Headers/Public/Firebase" "${PODS_ROOT}/Headers/Public/FirebaseAnalytics" "${PODS_ROOT}/Headers/Public/FirebaseAuth" "${PODS_ROOT}/Headers/Public/FirebaseCore" "${PODS_ROOT}/Headers/Public/FirebaseDatabase" "${PODS_ROOT}/Headers/Public/FirebaseInstanceID" "${PODS_ROOT}/Headers/Public/GTMSessionFetcher" "${PODS_ROOT}/Headers/Public/GoogleInterchangeUtilities" "${PODS_ROOT}/Headers/Public/GoogleSymbolUtilities" "${PODS_ROOT}/Headers/Public/GoogleToolboxForMac"
+LIBRARY_SEARCH_PATHS = $(inherited) "$PODS_CONFIGURATION_BUILD_DIR/GTMSessionFetcher" "$PODS_CONFIGURATION_BUILD_DIR/GoogleToolboxForMac"
+OTHER_CFLAGS = $(inherited) -isystem "${PODS_ROOT}/Headers/Public" -isystem "${PODS_ROOT}/Headers/Public/Firebase" -isystem "${PODS_ROOT}/Headers/Public/FirebaseAnalytics" -isystem "${PODS_ROOT}/Headers/Public/FirebaseAuth" -isystem "${PODS_ROOT}/Headers/Public/FirebaseCore" -isystem "${PODS_ROOT}/Headers/Public/FirebaseDatabase" -isystem "${PODS_ROOT}/Headers/Public/FirebaseInstanceID" -isystem "${PODS_ROOT}/Headers/Public/GTMSessionFetcher" -isystem "${PODS_ROOT}/Headers/Public/GoogleInterchangeUtilities" -isystem "${PODS_ROOT}/Headers/Public/GoogleSymbolUtilities" -isystem "${PODS_ROOT}/Headers/Public/GoogleToolboxForMac"
+OTHER_LDFLAGS = $(inherited) -ObjC -l"GTMSessionFetcher" -l"GoogleToolboxForMac" -l"c++" -l"icucore" -l"sqlite3" -l"z" -framework "AddressBook" -framework "CFNetwork" -framework "FirebaseAnalytics" -framework "FirebaseAuth" -framework "FirebaseCore" -framework "FirebaseDatabase" -framework "FirebaseInstanceID" -framework "GoogleInterchangeUtilities" -framework "GoogleSymbolUtilities" -framework "Security" -framework "StoreKit" -framework "SystemConfiguration"
+PODS_BUILD_DIR = $BUILD_DIR
+PODS_CONFIGURATION_BUILD_DIR = $PODS_BUILD_DIR/$(CONFIGURATION)$(EFFECTIVE_PLATFORM_NAME)
+PODS_ROOT = ${SRCROOT}/Pods