diff --git a/clang/include/clang/Analysis/RetainSummaryManager.h b/clang/include/clang/Analysis/RetainSummaryManager.h
index 6773ea48ef51..1174c4270868 100644
--- a/clang/include/clang/Analysis/RetainSummaryManager.h
+++ b/clang/include/clang/Analysis/RetainSummaryManager.h
@@ -1,762 +1,767 @@
 //=== RetainSummaryManager.h - Summaries for reference counting ---*- C++ -*--//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines summaries implementation for retain counting, which
 //  implements a reference count checker for Core Foundation and Cocoa
 //  on (Mac OS X).
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ANALYSIS_RETAINSUMMARY_MANAGER_H
 #define LLVM_CLANG_ANALYSIS_RETAINSUMMARY_MANAGER_H
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/ImmutableMap.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/ParentMap.h"
 #include "clang/Analysis/AnyCall.h"
 #include "clang/Analysis/SelectorExtras.h"
 #include "llvm/ADT/STLExtras.h"
 
 using namespace clang;
 
 namespace clang {
 namespace ento {
 
 /// Determines the object kind of a tracked object.
 enum class ObjKind {
   /// Indicates that the tracked object is a CF object.
   CF,
 
   /// Indicates that the tracked object is an Objective-C object.
   ObjC,
 
   /// Indicates that the tracked object could be a CF or Objective-C object.
   AnyObj,
 
   /// Indicates that the tracked object is a generalized object.
   Generalized,
 
   /// Indicates that the tracking object is a descendant of a
   /// referenced-counted OSObject, used in the Darwin kernel.
   OS
 };
 
 enum ArgEffectKind {
   /// There is no effect.
   DoNothing,
 
   /// The argument is treated as if an -autorelease message had been sent to
   /// the referenced object.
   Autorelease,
 
   /// The argument is treated as if the referenced object was deallocated.
   Dealloc,
 
   /// The argument has its reference count decreased by 1.
   DecRef,
 
   /// The argument has its reference count decreased by 1 to model
   /// a transferred bridge cast under ARC.
   DecRefBridgedTransferred,
 
   /// The argument has its reference count increased by 1.
   IncRef,
 
   /// The argument is a pointer to a retain-counted object; on exit, the new
   /// value of the pointer is a +0 value.
   UnretainedOutParameter,
 
   /// The argument is a pointer to a retain-counted object; on exit, the new
   /// value of the pointer is a +1 value.
   RetainedOutParameter,
 
   /// The argument is a pointer to a retain-counted object; on exit, the new
   /// value of the pointer is a +1 value iff the return code is zero.
   RetainedOutParameterOnZero,
 
   /// The argument is a pointer to a retain-counted object; on exit, the new
   /// value of the pointer is a +1 value iff the return code is non-zero.
   RetainedOutParameterOnNonZero,
 
   /// The argument is treated as potentially escaping, meaning that
   /// even when its reference count hits 0 it should be treated as still
   /// possibly being alive as someone else *may* be holding onto the object.
   MayEscape,
 
   /// All typestate tracking of the object ceases.  This is usually employed
   /// when the effect of the call is completely unknown.
   StopTracking,
 
   /// All typestate tracking of the object ceases.  Unlike StopTracking,
   /// this is also enforced when the method body is inlined.
   ///
   /// In some cases, we obtain a better summary for this checker
   /// by looking at the call site than by inlining the function.
   /// Signifies that we should stop tracking the symbol even if
   /// the function is inlined.
   StopTrackingHard,
 
   /// Performs the combined functionality of DecRef and StopTrackingHard.
   ///
   /// The models the effect that the called function decrements the reference
   /// count of the argument and all typestate tracking on that argument
   /// should cease.
   DecRefAndStopTrackingHard,
 };
 
 /// An ArgEffect summarizes the retain count behavior on an argument or receiver
 /// to a function or method.
 class ArgEffect {
   ArgEffectKind K;
   ObjKind O;
 public:
   explicit ArgEffect(ArgEffectKind K = DoNothing, ObjKind O = ObjKind::AnyObj)
       : K(K), O(O) {}
 
   ArgEffectKind getKind() const { return K; }
   ObjKind getObjKind() const { return O; }
 
   ArgEffect withKind(ArgEffectKind NewK) {
     return ArgEffect(NewK, O);
   }
 
   bool operator==(const ArgEffect &Other) const {
     return K == Other.K && O == Other.O;
   }
 };
 
 /// RetEffect summarizes a call's retain/release behavior with respect
 /// to its return value.
 class RetEffect {
 public:
   enum Kind {
     /// Indicates that no retain count information is tracked for
     /// the return value.
     NoRet,
 
     /// Indicates that the returned value is an owned (+1) symbol.
     OwnedSymbol,
 
     /// Indicates that the returned value is an object with retain count
     /// semantics but that it is not owned (+0).  This is the default
     /// for getters, etc.
     NotOwnedSymbol,
 
     /// Indicates that the return value is an owned object when the
     /// receiver is also a tracked object.
     OwnedWhenTrackedReceiver,
 
     // Treat this function as returning a non-tracked symbol even if
     // the function has been inlined. This is used where the call
     // site summary is more precise than the summary indirectly produced
     // by inlining the function
     NoRetHard
   };
 
 private:
   Kind K;
   ObjKind O;
 
   RetEffect(Kind k, ObjKind o = ObjKind::AnyObj) : K(k), O(o) {}
 
 public:
   Kind getKind() const { return K; }
 
   ObjKind getObjKind() const { return O; }
 
   bool isOwned() const {
     return K == OwnedSymbol || K == OwnedWhenTrackedReceiver;
   }
 
   bool notOwned() const {
     return K == NotOwnedSymbol;
   }
 
   bool operator==(const RetEffect &Other) const {
     return K == Other.K && O == Other.O;
   }
 
   static RetEffect MakeOwnedWhenTrackedReceiver() {
     return RetEffect(OwnedWhenTrackedReceiver, ObjKind::ObjC);
   }
 
   static RetEffect MakeOwned(ObjKind o) {
     return RetEffect(OwnedSymbol, o);
   }
   static RetEffect MakeNotOwned(ObjKind o) {
     return RetEffect(NotOwnedSymbol, o);
   }
   static RetEffect MakeNoRet() {
     return RetEffect(NoRet);
   }
   static RetEffect MakeNoRetHard() {
     return RetEffect(NoRetHard);
   }
 };
 
 /// A key identifying a summary.
 class ObjCSummaryKey {
   IdentifierInfo* II;
   Selector S;
 public:
   ObjCSummaryKey(IdentifierInfo* ii, Selector s)
     : II(ii), S(s) {}
 
   ObjCSummaryKey(const ObjCInterfaceDecl *d, Selector s)
     : II(d ? d->getIdentifier() : nullptr), S(s) {}
 
   ObjCSummaryKey(Selector s)
     : II(nullptr), S(s) {}
 
   IdentifierInfo *getIdentifier() const { return II; }
   Selector getSelector() const { return S; }
 };
 
 } // end namespace ento
 } // end namespace clang
 
 using namespace ento;
 
 namespace llvm {
 
 //===----------------------------------------------------------------------===//
 // Adapters for FoldingSet.
 //===----------------------------------------------------------------------===//
 template <> struct FoldingSetTrait<ArgEffect> {
 static inline void Profile(const ArgEffect X, FoldingSetNodeID &ID) {
   ID.AddInteger((unsigned) X.getKind());
   ID.AddInteger((unsigned) X.getObjKind());
 }
 };
 template <> struct FoldingSetTrait<RetEffect> {
   static inline void Profile(const RetEffect &X, FoldingSetNodeID &ID) {
     ID.AddInteger((unsigned) X.getKind());
     ID.AddInteger((unsigned) X.getObjKind());
 }
 };
 
 template <> struct DenseMapInfo<ObjCSummaryKey> {
   static inline ObjCSummaryKey getEmptyKey() {
     return ObjCSummaryKey(DenseMapInfo<IdentifierInfo*>::getEmptyKey(),
                           DenseMapInfo<Selector>::getEmptyKey());
   }
 
   static inline ObjCSummaryKey getTombstoneKey() {
     return ObjCSummaryKey(DenseMapInfo<IdentifierInfo*>::getTombstoneKey(),
                           DenseMapInfo<Selector>::getTombstoneKey());
   }
 
   static unsigned getHashValue(const ObjCSummaryKey &V) {
     typedef std::pair<IdentifierInfo*, Selector> PairTy;
     return DenseMapInfo<PairTy>::getHashValue(PairTy(V.getIdentifier(),
                                                      V.getSelector()));
   }
 
   static bool isEqual(const ObjCSummaryKey& LHS, const ObjCSummaryKey& RHS) {
     return LHS.getIdentifier() == RHS.getIdentifier() &&
            LHS.getSelector() == RHS.getSelector();
   }
 
 };
 
 } // end llvm namespace
 
 
 namespace clang {
 namespace ento {
 
 /// ArgEffects summarizes the effects of a function/method call on all of
 /// its arguments.
 typedef llvm::ImmutableMap<unsigned, ArgEffect> ArgEffects;
 
 /// Summary for a function with respect to ownership changes.
 class RetainSummary {
   /// Args - a map of (index, ArgEffect) pairs, where index
   ///  specifies the argument (starting from 0).  This can be sparsely
   ///  populated; arguments with no entry in Args use 'DefaultArgEffect'.
   ArgEffects Args;
 
   /// DefaultArgEffect - The default ArgEffect to apply to arguments that
   ///  do not have an entry in Args.
   ArgEffect DefaultArgEffect;
 
   /// Receiver - If this summary applies to an Objective-C message expression,
   ///  this is the effect applied to the state of the receiver.
   ArgEffect Receiver;
 
   /// Effect on "this" pointer - applicable only to C++ method calls.
   ArgEffect This;
 
   /// Ret - The effect on the return value.  Used to indicate if the
   ///  function/method call returns a new tracked symbol.
   RetEffect Ret;
 
 public:
   RetainSummary(ArgEffects A,
                 RetEffect R,
                 ArgEffect defaultEff,
                 ArgEffect ReceiverEff,
                 ArgEffect ThisEff)
     : Args(A), DefaultArgEffect(defaultEff), Receiver(ReceiverEff),
       This(ThisEff), Ret(R) {}
 
   /// getArg - Return the argument effect on the argument specified by
   ///  idx (starting from 0).
   ArgEffect getArg(unsigned idx) const {
     if (const ArgEffect *AE = Args.lookup(idx))
       return *AE;
 
     return DefaultArgEffect;
   }
 
   void addArg(ArgEffects::Factory &af, unsigned idx, ArgEffect e) {
     Args = af.add(Args, idx, e);
   }
 
   /// setDefaultArgEffect - Set the default argument effect.
   void setDefaultArgEffect(ArgEffect E) {
     DefaultArgEffect = E;
   }
 
   /// getRetEffect - Returns the effect on the return value of the call.
   RetEffect getRetEffect() const { return Ret; }
 
   /// setRetEffect - Set the effect of the return value of the call.
   void setRetEffect(RetEffect E) { Ret = E; }
 
 
   /// Sets the effect on the receiver of the message.
   void setReceiverEffect(ArgEffect e) { Receiver = e; }
 
   /// getReceiverEffect - Returns the effect on the receiver of the call.
   ///  This is only meaningful if the summary applies to an ObjCMessageExpr*.
   ArgEffect getReceiverEffect() const { return Receiver; }
 
   /// \return the effect on the "this" receiver of the method call.
   /// This is only meaningful if the summary applies to CXXMethodDecl*.
   ArgEffect getThisEffect() const { return This; }
 
+  ArgEffect getDefaultEffect() const { return DefaultArgEffect; }
+
   /// Set the effect of the method on "this".
   void setThisEffect(ArgEffect e) { This = e; }
 
   bool isNoop() const {
     return Ret == RetEffect::MakeNoRet() && Receiver.getKind() == DoNothing
       && DefaultArgEffect.getKind() == MayEscape && This.getKind() == DoNothing
       && Args.isEmpty();
   }
 
   /// Test if two retain summaries are identical. Note that merely equivalent
   /// summaries are not necessarily identical (for example, if an explicit
   /// argument effect matches the default effect).
   bool operator==(const RetainSummary &Other) const {
     return Args == Other.Args && DefaultArgEffect == Other.DefaultArgEffect &&
            Receiver == Other.Receiver && This == Other.This && Ret == Other.Ret;
   }
 
   /// Profile this summary for inclusion in a FoldingSet.
   void Profile(llvm::FoldingSetNodeID& ID) const {
     ID.Add(Args);
     ID.Add(DefaultArgEffect);
     ID.Add(Receiver);
     ID.Add(This);
     ID.Add(Ret);
   }
 
   /// A retain summary is simple if it has no ArgEffects other than the default.
   bool isSimple() const {
     return Args.isEmpty();
   }
 
   ArgEffects getArgEffects() const { return Args; }
 
 private:
   ArgEffect getDefaultArgEffect() const { return DefaultArgEffect; }
 
   friend class RetainSummaryManager;
 };
 
 class ObjCSummaryCache {
   typedef llvm::DenseMap<ObjCSummaryKey, const RetainSummary *> MapTy;
   MapTy M;
 public:
   ObjCSummaryCache() {}
 
   const RetainSummary * find(const ObjCInterfaceDecl *D, Selector S) {
     // Do a lookup with the (D,S) pair.  If we find a match return
     // the iterator.
     ObjCSummaryKey K(D, S);
     MapTy::iterator I = M.find(K);
 
     if (I != M.end())
       return I->second;
     if (!D)
       return nullptr;
 
     // Walk the super chain.  If we find a hit with a parent, we'll end
     // up returning that summary.  We actually allow that key (null,S), as
     // we cache summaries for the null ObjCInterfaceDecl* to allow us to
     // generate initial summaries without having to worry about NSObject
     // being declared.
     // FIXME: We may change this at some point.
     for (ObjCInterfaceDecl *C=D->getSuperClass() ;; C=C->getSuperClass()) {
       if ((I = M.find(ObjCSummaryKey(C, S))) != M.end())
         break;
 
       if (!C)
         return nullptr;
     }
 
     // Cache the summary with original key to make the next lookup faster
     // and return the iterator.
     const RetainSummary *Summ = I->second;
     M[K] = Summ;
     return Summ;
   }
 
   const RetainSummary *find(IdentifierInfo* II, Selector S) {
     // FIXME: Class method lookup.  Right now we don't have a good way
     // of going between IdentifierInfo* and the class hierarchy.
     MapTy::iterator I = M.find(ObjCSummaryKey(II, S));
 
     if (I == M.end())
       I = M.find(ObjCSummaryKey(S));
 
     return I == M.end() ? nullptr : I->second;
   }
 
   const RetainSummary *& operator[](ObjCSummaryKey K) {
     return M[K];
   }
 
   const RetainSummary *& operator[](Selector S) {
     return M[ ObjCSummaryKey(S) ];
   }
 };
 
 class RetainSummaryTemplate;
 
 class RetainSummaryManager {
   typedef llvm::DenseMap<const FunctionDecl*, const RetainSummary *>
           FuncSummariesTy;
 
   typedef ObjCSummaryCache ObjCMethodSummariesTy;
 
   typedef llvm::FoldingSetNodeWrapper<RetainSummary> CachedSummaryNode;
 
   /// Ctx - The ASTContext object for the analyzed ASTs.
   ASTContext &Ctx;
 
   /// Records whether or not the analyzed code runs in ARC mode.
   const bool ARCEnabled;
 
   /// Track Objective-C and CoreFoundation objects.
   const bool TrackObjCAndCFObjects;
 
   /// Track sublcasses of OSObject.
   const bool TrackOSObjects;
 
   /// FuncSummaries - A map from FunctionDecls to summaries.
   FuncSummariesTy FuncSummaries;
 
   /// ObjCClassMethodSummaries - A map from selectors (for instance methods)
   ///  to summaries.
   ObjCMethodSummariesTy ObjCClassMethodSummaries;
 
   /// ObjCMethodSummaries - A map from selectors to summaries.
   ObjCMethodSummariesTy ObjCMethodSummaries;
 
   /// BPAlloc - A BumpPtrAllocator used for allocating summaries, ArgEffects,
   ///  and all other data used by the checker.
   llvm::BumpPtrAllocator BPAlloc;
 
   /// AF - A factory for ArgEffects objects.
   ArgEffects::Factory AF;
 
   /// ObjCAllocRetE - Default return effect for methods returning Objective-C
   ///  objects.
   RetEffect ObjCAllocRetE;
 
   /// ObjCInitRetE - Default return effect for init methods returning
   ///   Objective-C objects.
   RetEffect ObjCInitRetE;
 
   /// SimpleSummaries - Used for uniquing summaries that don't have special
   /// effects.
   llvm::FoldingSet<CachedSummaryNode> SimpleSummaries;
 
   /// Create an OS object at +1.
   const RetainSummary *getOSSummaryCreateRule(const FunctionDecl *FD);
 
   /// Get an OS object at +0.
   const RetainSummary *getOSSummaryGetRule(const FunctionDecl *FD);
 
   /// Increment the reference count on OS object.
   const RetainSummary *getOSSummaryRetainRule(const FunctionDecl *FD);
 
   /// Decrement the reference count on OS object.
   const RetainSummary *getOSSummaryReleaseRule(const FunctionDecl *FD);
 
   /// Free the OS object.
   const RetainSummary *getOSSummaryFreeRule(const FunctionDecl *FD);
 
   const RetainSummary *getUnarySummary(const FunctionType* FT,
                                        ArgEffectKind AE);
 
   const RetainSummary *getCFSummaryCreateRule(const FunctionDecl *FD);
   const RetainSummary *getCFSummaryGetRule(const FunctionDecl *FD);
   const RetainSummary *getCFCreateGetRuleSummary(const FunctionDecl *FD);
 
   const RetainSummary *getPersistentSummary(const RetainSummary &OldSumm);
 
   const RetainSummary *
   getPersistentSummary(RetEffect RetEff, ArgEffects ScratchArgs,
                        ArgEffect ReceiverEff = ArgEffect(DoNothing),
                        ArgEffect DefaultEff = ArgEffect(MayEscape),
                        ArgEffect ThisEff = ArgEffect(DoNothing)) {
     RetainSummary Summ(ScratchArgs, RetEff, DefaultEff, ReceiverEff, ThisEff);
     return getPersistentSummary(Summ);
   }
 
   const RetainSummary *getDoNothingSummary() {
     return getPersistentSummary(RetEffect::MakeNoRet(),
                                 ArgEffects(AF.getEmptyMap()),
                                 ArgEffect(DoNothing), ArgEffect(DoNothing));
   }
 
   const RetainSummary *getDefaultSummary() {
     return getPersistentSummary(RetEffect::MakeNoRet(),
                                 ArgEffects(AF.getEmptyMap()),
                                 ArgEffect(DoNothing), ArgEffect(MayEscape));
   }
 
   const RetainSummary *getPersistentStopSummary() {
     return getPersistentSummary(
         RetEffect::MakeNoRet(), ArgEffects(AF.getEmptyMap()),
         ArgEffect(StopTracking), ArgEffect(StopTracking));
   }
 
   void InitializeClassMethodSummaries();
   void InitializeMethodSummaries();
 
   void addNSObjectClsMethSummary(Selector S, const RetainSummary *Summ) {
     ObjCClassMethodSummaries[S] = Summ;
   }
 
   void addNSObjectMethSummary(Selector S, const RetainSummary *Summ) {
     ObjCMethodSummaries[S] = Summ;
   }
 
   void addClassMethSummary(const char* Cls, const char* name,
                            const RetainSummary *Summ, bool isNullary = true) {
     IdentifierInfo* ClsII = &Ctx.Idents.get(Cls);
     Selector S = isNullary ? GetNullarySelector(name, Ctx)
                            : GetUnarySelector(name, Ctx);
     ObjCClassMethodSummaries[ObjCSummaryKey(ClsII, S)]  = Summ;
   }
 
   void addInstMethSummary(const char* Cls, const char* nullaryName,
                           const RetainSummary *Summ) {
     IdentifierInfo* ClsII = &Ctx.Idents.get(Cls);
     Selector S = GetNullarySelector(nullaryName, Ctx);
     ObjCMethodSummaries[ObjCSummaryKey(ClsII, S)]  = Summ;
   }
 
   template <typename... Keywords>
   void addMethodSummary(IdentifierInfo *ClsII, ObjCMethodSummariesTy &Summaries,
                         const RetainSummary *Summ, Keywords *... Kws) {
     Selector S = getKeywordSelector(Ctx, Kws...);
     Summaries[ObjCSummaryKey(ClsII, S)] = Summ;
   }
 
   template <typename... Keywords>
   void addInstMethSummary(const char *Cls, const RetainSummary *Summ,
                           Keywords *... Kws) {
     addMethodSummary(&Ctx.Idents.get(Cls), ObjCMethodSummaries, Summ, Kws...);
   }
 
   template <typename... Keywords>
   void addClsMethSummary(const char *Cls, const RetainSummary *Summ,
                          Keywords *... Kws) {
     addMethodSummary(&Ctx.Idents.get(Cls), ObjCClassMethodSummaries, Summ,
                      Kws...);
   }
 
   template <typename... Keywords>
   void addClsMethSummary(IdentifierInfo *II, const RetainSummary *Summ,
                          Keywords *... Kws) {
     addMethodSummary(II, ObjCClassMethodSummaries, Summ, Kws...);
   }
 
   const RetainSummary * generateSummary(const FunctionDecl *FD,
                                         bool &AllowAnnotations);
 
   /// Return a summary for OSObject, or nullptr if not found.
   const RetainSummary *getSummaryForOSObject(const FunctionDecl *FD,
                                              StringRef FName, QualType RetTy);
 
   /// Return a summary for Objective-C or CF object, or nullptr if not found.
   const RetainSummary *getSummaryForObjCOrCFObject(
     const FunctionDecl *FD,
     StringRef FName,
     QualType RetTy,
     const FunctionType *FT,
     bool &AllowAnnotations);
 
   /// Apply the annotation of {@code pd} in function {@code FD}
   /// to the resulting summary stored in out-parameter {@code Template}.
   /// \return whether an annotation was applied.
   bool applyParamAnnotationEffect(const ParmVarDecl *pd, unsigned parm_idx,
                                   const NamedDecl *FD,
                                   RetainSummaryTemplate &Template);
 
 public:
   RetainSummaryManager(ASTContext &ctx, bool trackObjCAndCFObjects,
                        bool trackOSObjects)
       : Ctx(ctx), ARCEnabled((bool)Ctx.getLangOpts().ObjCAutoRefCount),
         TrackObjCAndCFObjects(trackObjCAndCFObjects),
         TrackOSObjects(trackOSObjects), AF(BPAlloc),
         ObjCAllocRetE(ARCEnabled ? RetEffect::MakeNotOwned(ObjKind::ObjC)
                                  : RetEffect::MakeOwned(ObjKind::ObjC)),
         ObjCInitRetE(ARCEnabled ? RetEffect::MakeNotOwned(ObjKind::ObjC)
                                 : RetEffect::MakeOwnedWhenTrackedReceiver()) {
     InitializeClassMethodSummaries();
     InitializeMethodSummaries();
   }
 
   enum class BehaviorSummary {
     // Function does not return.
     NoOp,
 
     // Function returns the first argument.
     Identity,
 
     // Function returns "this" argument.
     IdentityThis,
 
     // Function either returns zero, or the input parameter.
     IdentityOrZero
   };
 
   Optional<BehaviorSummary> canEval(const CallExpr *CE, const FunctionDecl *FD,
                                     bool &hasTrustedImplementationAnnotation);
 
   /// \return Whether the type corresponds to a known smart pointer
   /// implementation (that is, everything about it is inlineable).
   static bool isKnownSmartPointer(QualType QT);
 
   bool isTrustedReferenceCountImplementation(const FunctionDecl *FD);
 
   const RetainSummary *getSummary(AnyCall C,
                                   bool HasNonZeroCallbackArg=false,
                                   bool IsReceiverUnconsumedSelf=false,
                                   QualType ReceiverType={});
 
   RetEffect getObjAllocRetEffect() const { return ObjCAllocRetE; }
 
 private:
 
   /// getMethodSummary - This version of getMethodSummary is used to query
   ///  the summary for the current method being analyzed.
   const RetainSummary *getMethodSummary(const ObjCMethodDecl *MD);
 
   const RetainSummary *getFunctionSummary(const FunctionDecl *FD);
 
   const RetainSummary *getMethodSummary(Selector S, const ObjCInterfaceDecl *ID,
                                         const ObjCMethodDecl *MD,
                                         QualType RetTy,
                                         ObjCMethodSummariesTy &CachedSummaries);
 
   const RetainSummary *
   getInstanceMethodSummary(const ObjCMessageExpr *ME, QualType ReceiverType);
 
   const RetainSummary *getClassMethodSummary(const ObjCMessageExpr *ME);
 
   const RetainSummary *getStandardMethodSummary(const ObjCMethodDecl *MD,
                                                 Selector S, QualType RetTy);
 
   /// Determine if there is a special return effect for this function or method.
   Optional<RetEffect> getRetEffectFromAnnotations(QualType RetTy,
                                                   const Decl *D);
 
   void updateSummaryFromAnnotations(const RetainSummary *&Summ,
                                     const ObjCMethodDecl *MD);
 
   void updateSummaryFromAnnotations(const RetainSummary *&Summ,
                                     const FunctionDecl *FD);
 
   const RetainSummary *updateSummaryForNonZeroCallbackArg(const RetainSummary *S,
                                                           AnyCall &C);
 
   /// Special case '[super init];' and '[self init];'
   ///
   /// Even though calling '[super init]' without assigning the result to self
   /// and checking if the parent returns 'nil' is a bad pattern, it is common.
   /// Additionally, our Self Init checker already warns about it. To avoid
   /// overwhelming the user with messages from both checkers, we model the case
   /// of '[super init]' in cases when it is not consumed by another expression
   /// as if the call preserves the value of 'self'; essentially, assuming it can
   /// never fail and return 'nil'.
   /// Note, we don't want to just stop tracking the value since we want the
   /// RetainCount checker to report leaks and use-after-free if SelfInit checker
   /// is turned off.
   void updateSummaryForReceiverUnconsumedSelf(const RetainSummary *&S);
 
+  /// Set argument types for arguments which are not doing anything.
+  void updateSummaryForArgumentTypes(const AnyCall &C, const RetainSummary *&RS);
+
   /// Determine whether a declaration {@code D} of correspondent type (return
   /// type for functions/methods) {@code QT} has any of the given attributes,
   /// provided they pass necessary validation checks AND tracking the given
   /// attribute is enabled.
   /// Returns the object kind corresponding to the present attribute, or None,
   /// if none of the specified attributes are present.
   /// Crashes if passed an attribute which is not explicitly handled.
   template <class T>
   Optional<ObjKind> hasAnyEnabledAttrOf(const Decl *D, QualType QT);
 
   template <class T1, class T2, class... Others>
   Optional<ObjKind> hasAnyEnabledAttrOf(const Decl *D, QualType QT);
 
   friend class RetainSummaryTemplate;
 };
 
 
 // Used to avoid allocating long-term (BPAlloc'd) memory for default retain
 // summaries. If a function or method looks like it has a default summary, but
 // it has annotations, the annotations are added to the stack-based template
 // and then copied into managed memory.
 class RetainSummaryTemplate {
   RetainSummaryManager &Manager;
   const RetainSummary *&RealSummary;
   RetainSummary ScratchSummary;
   bool Accessed;
 public:
   RetainSummaryTemplate(const RetainSummary *&real, RetainSummaryManager &mgr)
     : Manager(mgr), RealSummary(real), ScratchSummary(*real), Accessed(false) {}
 
   ~RetainSummaryTemplate() {
     if (Accessed)
       RealSummary = Manager.getPersistentSummary(ScratchSummary);
   }
 
   RetainSummary &operator*() {
     Accessed = true;
     return ScratchSummary;
   }
 
   RetainSummary *operator->() {
     Accessed = true;
     return &ScratchSummary;
   }
 };
 
 } // end namespace ento
 } // end namespace clang
 
 #endif
diff --git a/clang/lib/Analysis/RetainSummaryManager.cpp b/clang/lib/Analysis/RetainSummaryManager.cpp
index 9a514efb7c30..c3611711974a 100644
--- a/clang/lib/Analysis/RetainSummaryManager.cpp
+++ b/clang/lib/Analysis/RetainSummaryManager.cpp
@@ -1,1229 +1,1272 @@
 //== RetainSummaryManager.cpp - Summaries for reference counting --*- C++ -*--//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines summaries implementation for retain counting, which
 //  implements a reference count checker for Core Foundation, Cocoa
 //  and OSObject (on Mac OS X).
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Analysis/DomainSpecific/CocoaConventions.h"
 #include "clang/Analysis/RetainSummaryManager.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/ParentMap.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 
 using namespace clang;
 using namespace ento;
 
 template <class T>
 constexpr static bool isOneOf() {
   return false;
 }
 
 /// Helper function to check whether the class is one of the
 /// rest of varargs.
 template <class T, class P, class... ToCompare>
 constexpr static bool isOneOf() {
   return std::is_same<T, P>::value || isOneOf<T, ToCompare...>();
 }
 
 namespace {
 
 /// Fake attribute class for RC* attributes.
 struct GeneralizedReturnsRetainedAttr {
   static bool classof(const Attr *A) {
     if (auto AA = dyn_cast<AnnotateAttr>(A))
       return AA->getAnnotation() == "rc_ownership_returns_retained";
     return false;
   }
 };
 
 struct GeneralizedReturnsNotRetainedAttr {
   static bool classof(const Attr *A) {
     if (auto AA = dyn_cast<AnnotateAttr>(A))
       return AA->getAnnotation() == "rc_ownership_returns_not_retained";
     return false;
   }
 };
 
 struct GeneralizedConsumedAttr {
   static bool classof(const Attr *A) {
     if (auto AA = dyn_cast<AnnotateAttr>(A))
       return AA->getAnnotation() == "rc_ownership_consumed";
     return false;
   }
 };
 
 }
 
 template <class T>
 Optional<ObjKind> RetainSummaryManager::hasAnyEnabledAttrOf(const Decl *D,
                                                             QualType QT) {
   ObjKind K;
   if (isOneOf<T, CFConsumedAttr, CFReturnsRetainedAttr,
               CFReturnsNotRetainedAttr>()) {
     if (!TrackObjCAndCFObjects)
       return None;
 
     K = ObjKind::CF;
   } else if (isOneOf<T, NSConsumedAttr, NSConsumesSelfAttr,
                      NSReturnsAutoreleasedAttr, NSReturnsRetainedAttr,
                      NSReturnsNotRetainedAttr, NSConsumesSelfAttr>()) {
 
     if (!TrackObjCAndCFObjects)
       return None;
 
     if (isOneOf<T, NSReturnsRetainedAttr, NSReturnsAutoreleasedAttr,
                 NSReturnsNotRetainedAttr>() &&
         !cocoa::isCocoaObjectRef(QT))
       return None;
     K = ObjKind::ObjC;
   } else if (isOneOf<T, OSConsumedAttr, OSConsumesThisAttr,
                      OSReturnsNotRetainedAttr, OSReturnsRetainedAttr,
                      OSReturnsRetainedOnZeroAttr,
                      OSReturnsRetainedOnNonZeroAttr>()) {
     if (!TrackOSObjects)
       return None;
     K = ObjKind::OS;
   } else if (isOneOf<T, GeneralizedReturnsNotRetainedAttr,
                      GeneralizedReturnsRetainedAttr,
                      GeneralizedConsumedAttr>()) {
     K = ObjKind::Generalized;
   } else {
     llvm_unreachable("Unexpected attribute");
   }
   if (D->hasAttr<T>())
     return K;
   return None;
 }
 
 template <class T1, class T2, class... Others>
 Optional<ObjKind> RetainSummaryManager::hasAnyEnabledAttrOf(const Decl *D,
                                                             QualType QT) {
   if (auto Out = hasAnyEnabledAttrOf<T1>(D, QT))
     return Out;
   return hasAnyEnabledAttrOf<T2, Others...>(D, QT);
 }
 
 const RetainSummary *
 RetainSummaryManager::getPersistentSummary(const RetainSummary &OldSumm) {
   // Unique "simple" summaries -- those without ArgEffects.
   if (OldSumm.isSimple()) {
     ::llvm::FoldingSetNodeID ID;
     OldSumm.Profile(ID);
 
     void *Pos;
     CachedSummaryNode *N = SimpleSummaries.FindNodeOrInsertPos(ID, Pos);
 
     if (!N) {
       N = (CachedSummaryNode *) BPAlloc.Allocate<CachedSummaryNode>();
       new (N) CachedSummaryNode(OldSumm);
       SimpleSummaries.InsertNode(N, Pos);
     }
 
     return &N->getValue();
   }
 
   RetainSummary *Summ = (RetainSummary *) BPAlloc.Allocate<RetainSummary>();
   new (Summ) RetainSummary(OldSumm);
   return Summ;
 }
 
 static bool isSubclass(const Decl *D,
                        StringRef ClassName) {
   using namespace ast_matchers;
   DeclarationMatcher SubclassM = cxxRecordDecl(isSameOrDerivedFrom(ClassName));
   return !(match(SubclassM, *D, D->getASTContext()).empty());
 }
 
 static bool isOSObjectSubclass(const Decl *D) {
-  return isSubclass(D, "OSMetaClassBase");
+  return D && isSubclass(D, "OSMetaClassBase");
 }
 
 static bool isOSObjectDynamicCast(StringRef S) {
   return S == "safeMetaCast";
 }
 
 static bool isOSObjectThisCast(StringRef S) {
   return S == "metaCast";
 }
 
+
+static bool isOSObjectPtr(QualType QT) {
+  return isOSObjectSubclass(QT->getPointeeCXXRecordDecl());
+}
+
+static bool isISLObjectRef(QualType Ty) {
+  return StringRef(Ty.getAsString()).startswith("isl_");
+}
+
 static bool isOSIteratorSubclass(const Decl *D) {
   return isSubclass(D, "OSIterator");
 }
 
 static bool hasRCAnnotation(const Decl *D, StringRef rcAnnotation) {
   for (const auto *Ann : D->specific_attrs<AnnotateAttr>()) {
     if (Ann->getAnnotation() == rcAnnotation)
       return true;
   }
   return false;
 }
 
 static bool isRetain(const FunctionDecl *FD, StringRef FName) {
   return FName.startswith_lower("retain") || FName.endswith_lower("retain");
 }
 
 static bool isRelease(const FunctionDecl *FD, StringRef FName) {
   return FName.startswith_lower("release") || FName.endswith_lower("release");
 }
 
 static bool isAutorelease(const FunctionDecl *FD, StringRef FName) {
   return FName.startswith_lower("autorelease") ||
          FName.endswith_lower("autorelease");
 }
 
 static bool isMakeCollectable(StringRef FName) {
   return FName.contains_lower("MakeCollectable");
 }
 
 /// A function is OSObject related if it is declared on a subclass
 /// of OSObject, or any of the parameters is a subclass of an OSObject.
 static bool isOSObjectRelated(const CXXMethodDecl *MD) {
   if (isOSObjectSubclass(MD->getParent()))
     return true;
 
   for (ParmVarDecl *Param : MD->parameters()) {
     QualType PT = Param->getType()->getPointeeType();
     if (!PT.isNull())
       if (CXXRecordDecl *RD = PT->getAsCXXRecordDecl())
         if (isOSObjectSubclass(RD))
           return true;
   }
 
   return false;
 }
 
 bool
 RetainSummaryManager::isKnownSmartPointer(QualType QT) {
   QT = QT.getCanonicalType();
   const auto *RD = QT->getAsCXXRecordDecl();
   if (!RD)
     return false;
   const IdentifierInfo *II = RD->getIdentifier();
   if (II && II->getName() == "smart_ptr")
     if (const auto *ND = dyn_cast<NamespaceDecl>(RD->getDeclContext()))
       if (ND->getNameAsString() == "os")
         return true;
   return false;
 }
 
 const RetainSummary *
 RetainSummaryManager::getSummaryForOSObject(const FunctionDecl *FD,
                                             StringRef FName, QualType RetTy) {
   if (RetTy->isPointerType()) {
     const CXXRecordDecl *PD = RetTy->getPointeeType()->getAsCXXRecordDecl();
     if (PD && isOSObjectSubclass(PD)) {
       if (const IdentifierInfo *II = FD->getIdentifier()) {
         StringRef FuncName = II->getName();
         if (isOSObjectDynamicCast(FuncName) || isOSObjectThisCast(FuncName))
           return getDefaultSummary();
 
         // All objects returned with functions *not* starting with
         // get, or iterators, are returned at +1.
         if ((!FuncName.startswith("get") && !FuncName.startswith("Get")) ||
             isOSIteratorSubclass(PD)) {
           return getOSSummaryCreateRule(FD);
         } else {
           return getOSSummaryGetRule(FD);
         }
       }
     }
   }
 
   if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
     const CXXRecordDecl *Parent = MD->getParent();
     if (TrackOSObjects && Parent && isOSObjectSubclass(Parent)) {
       if (FName == "release" || FName == "taggedRelease")
         return getOSSummaryReleaseRule(FD);
 
       if (FName == "retain" || FName == "taggedRetain")
         return getOSSummaryRetainRule(FD);
 
       if (FName == "free")
         return getOSSummaryFreeRule(FD);
 
       if (MD->getOverloadedOperator() == OO_New)
         return getOSSummaryCreateRule(MD);
     }
   }
 
   return nullptr;
 }
 
 const RetainSummary *RetainSummaryManager::getSummaryForObjCOrCFObject(
     const FunctionDecl *FD,
     StringRef FName,
     QualType RetTy,
     const FunctionType *FT,
     bool &AllowAnnotations) {
 
   ArgEffects ScratchArgs(AF.getEmptyMap());
 
   std::string RetTyName = RetTy.getAsString();
   if (FName == "pthread_create" || FName == "pthread_setspecific") {
     // Part of: <rdar://problem/7299394> and <rdar://problem/11282706>.
     // This will be addressed better with IPA.
     return getPersistentStopSummary();
   } else if(FName == "NSMakeCollectable") {
     // Handle: id NSMakeCollectable(CFTypeRef)
     AllowAnnotations = false;
     return RetTy->isObjCIdType() ? getUnarySummary(FT, DoNothing)
                                  : getPersistentStopSummary();
   } else if (FName == "CMBufferQueueDequeueAndRetain" ||
              FName == "CMBufferQueueDequeueIfDataReadyAndRetain") {
     // Part of: <rdar://problem/39390714>.
     return getPersistentSummary(RetEffect::MakeOwned(ObjKind::CF),
                                 ScratchArgs,
                                 ArgEffect(DoNothing),
                                 ArgEffect(DoNothing));
   } else if (FName == "CFPlugInInstanceCreate") {
     return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs);
   } else if (FName == "IORegistryEntrySearchCFProperty" ||
              (RetTyName == "CFMutableDictionaryRef" &&
               (FName == "IOBSDNameMatching" || FName == "IOServiceMatching" ||
                FName == "IOServiceNameMatching" ||
                FName == "IORegistryEntryIDMatching" ||
                FName == "IOOpenFirmwarePathMatching"))) {
     // Part of <rdar://problem/6961230>. (IOKit)
     // This should be addressed using a API table.
     return getPersistentSummary(RetEffect::MakeOwned(ObjKind::CF), ScratchArgs,
                                 ArgEffect(DoNothing), ArgEffect(DoNothing));
   } else if (FName == "IOServiceGetMatchingService" ||
              FName == "IOServiceGetMatchingServices") {
     // FIXES: <rdar://problem/6326900>
     // This should be addressed using a API table.  This strcmp is also
     // a little gross, but there is no need to super optimize here.
     ScratchArgs = AF.add(ScratchArgs, 1, ArgEffect(DecRef, ObjKind::CF));
     return getPersistentSummary(RetEffect::MakeNoRet(),
                                 ScratchArgs,
                                 ArgEffect(DoNothing), ArgEffect(DoNothing));
   } else if (FName == "IOServiceAddNotification" ||
              FName == "IOServiceAddMatchingNotification") {
     // Part of <rdar://problem/6961230>. (IOKit)
     // This should be addressed using a API table.
     ScratchArgs = AF.add(ScratchArgs, 2, ArgEffect(DecRef, ObjKind::CF));
     return getPersistentSummary(RetEffect::MakeNoRet(),
                                 ScratchArgs,
                                 ArgEffect(DoNothing), ArgEffect(DoNothing));
   } else if (FName == "CVPixelBufferCreateWithBytes") {
     // FIXES: <rdar://problem/7283567>
     // Eventually this can be improved by recognizing that the pixel
     // buffer passed to CVPixelBufferCreateWithBytes is released via
     // a callback and doing full IPA to make sure this is done correctly.
     // FIXME: This function has an out parameter that returns an
     // allocated object.
     ScratchArgs = AF.add(ScratchArgs, 7, ArgEffect(StopTracking));
     return getPersistentSummary(RetEffect::MakeNoRet(),
                                 ScratchArgs,
                                 ArgEffect(DoNothing), ArgEffect(DoNothing));
   } else if (FName == "CGBitmapContextCreateWithData") {
     // FIXES: <rdar://problem/7358899>
     // Eventually this can be improved by recognizing that 'releaseInfo'
     // passed to CGBitmapContextCreateWithData is released via
     // a callback and doing full IPA to make sure this is done correctly.
     ScratchArgs = AF.add(ScratchArgs, 8, ArgEffect(ArgEffect(StopTracking)));
     return getPersistentSummary(RetEffect::MakeOwned(ObjKind::CF), ScratchArgs,
                                 ArgEffect(DoNothing), ArgEffect(DoNothing));
   } else if (FName == "CVPixelBufferCreateWithPlanarBytes") {
     // FIXES: <rdar://problem/7283567>
     // Eventually this can be improved by recognizing that the pixel
     // buffer passed to CVPixelBufferCreateWithPlanarBytes is released
     // via a callback and doing full IPA to make sure this is done
     // correctly.
     ScratchArgs = AF.add(ScratchArgs, 12, ArgEffect(StopTracking));
     return getPersistentSummary(RetEffect::MakeNoRet(),
                                 ScratchArgs,
                                 ArgEffect(DoNothing), ArgEffect(DoNothing));
   } else if (FName == "VTCompressionSessionEncodeFrame") {
     // The context argument passed to VTCompressionSessionEncodeFrame()
     // is passed to the callback specified when creating the session
     // (e.g. with VTCompressionSessionCreate()) which can release it.
     // To account for this possibility, conservatively stop tracking
     // the context.
     ScratchArgs = AF.add(ScratchArgs, 5, ArgEffect(StopTracking));
     return getPersistentSummary(RetEffect::MakeNoRet(),
                                 ScratchArgs,
                                 ArgEffect(DoNothing), ArgEffect(DoNothing));
   } else if (FName == "dispatch_set_context" ||
              FName == "xpc_connection_set_context") {
     // <rdar://problem/11059275> - The analyzer currently doesn't have
     // a good way to reason about the finalizer function for libdispatch.
     // If we pass a context object that is memory managed, stop tracking it.
     // <rdar://problem/13783514> - Same problem, but for XPC.
     // FIXME: this hack should possibly go away once we can handle
     // libdispatch and XPC finalizers.
     ScratchArgs = AF.add(ScratchArgs, 1, ArgEffect(StopTracking));
     return getPersistentSummary(RetEffect::MakeNoRet(),
                                 ScratchArgs,
                                 ArgEffect(DoNothing), ArgEffect(DoNothing));
   } else if (FName.startswith("NSLog")) {
     return getDoNothingSummary();
   } else if (FName.startswith("NS") &&
              (FName.find("Insert") != StringRef::npos)) {
     // Whitelist NSXXInsertXX, for example NSMapInsertIfAbsent, since they can
     // be deallocated by NSMapRemove. (radar://11152419)
     ScratchArgs = AF.add(ScratchArgs, 1, ArgEffect(StopTracking));
     ScratchArgs = AF.add(ScratchArgs, 2, ArgEffect(StopTracking));
     return getPersistentSummary(RetEffect::MakeNoRet(),
                                 ScratchArgs, ArgEffect(DoNothing),
                                 ArgEffect(DoNothing));
   }
 
   if (RetTy->isPointerType()) {
 
     // For CoreFoundation ('CF') types.
     if (cocoa::isRefType(RetTy, "CF", FName)) {
       if (isRetain(FD, FName)) {
         // CFRetain isn't supposed to be annotated. However, this may as
         // well be a user-made "safe" CFRetain function that is incorrectly
         // annotated as cf_returns_retained due to lack of better options.
         // We want to ignore such annotation.
         AllowAnnotations = false;
 
         return getUnarySummary(FT, IncRef);
       } else if (isAutorelease(FD, FName)) {
         // The headers use cf_consumed, but we can fully model CFAutorelease
         // ourselves.
         AllowAnnotations = false;
 
         return getUnarySummary(FT, Autorelease);
       } else if (isMakeCollectable(FName)) {
         AllowAnnotations = false;
         return getUnarySummary(FT, DoNothing);
       } else {
         return getCFCreateGetRuleSummary(FD);
       }
     }
 
     // For CoreGraphics ('CG') and CoreVideo ('CV') types.
     if (cocoa::isRefType(RetTy, "CG", FName) ||
         cocoa::isRefType(RetTy, "CV", FName)) {
       if (isRetain(FD, FName))
         return getUnarySummary(FT, IncRef);
       else
         return getCFCreateGetRuleSummary(FD);
     }
 
     // For all other CF-style types, use the Create/Get
     // rule for summaries but don't support Retain functions
     // with framework-specific prefixes.
     if (coreFoundation::isCFObjectRef(RetTy)) {
       return getCFCreateGetRuleSummary(FD);
     }
 
     if (FD->hasAttr<CFAuditedTransferAttr>()) {
       return getCFCreateGetRuleSummary(FD);
     }
   }
 
   // Check for release functions, the only kind of functions that we care
   // about that don't return a pointer type.
   if (FName.startswith("CG") || FName.startswith("CF")) {
     // Test for 'CGCF'.
     FName = FName.substr(FName.startswith("CGCF") ? 4 : 2);
 
     if (isRelease(FD, FName))
       return getUnarySummary(FT, DecRef);
     else {
       assert(ScratchArgs.isEmpty());
       // Remaining CoreFoundation and CoreGraphics functions.
       // We use to assume that they all strictly followed the ownership idiom
       // and that ownership cannot be transferred.  While this is technically
       // correct, many methods allow a tracked object to escape.  For example:
       //
       //   CFMutableDictionaryRef x = CFDictionaryCreateMutable(...);
       //   CFDictionaryAddValue(y, key, x);
       //   CFRelease(x);
       //   ... it is okay to use 'x' since 'y' has a reference to it
       //
       // We handle this and similar cases with the follow heuristic.  If the
       // function name contains "InsertValue", "SetValue", "AddValue",
       // "AppendValue", or "SetAttribute", then we assume that arguments may
       // "escape."  This means that something else holds on to the object,
       // allowing it be used even after its local retain count drops to 0.
       ArgEffectKind E =
           (StrInStrNoCase(FName, "InsertValue") != StringRef::npos ||
            StrInStrNoCase(FName, "AddValue") != StringRef::npos ||
            StrInStrNoCase(FName, "SetValue") != StringRef::npos ||
            StrInStrNoCase(FName, "AppendValue") != StringRef::npos ||
            StrInStrNoCase(FName, "SetAttribute") != StringRef::npos)
               ? MayEscape
               : DoNothing;
 
       return getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
                                   ArgEffect(DoNothing), ArgEffect(E, ObjKind::CF));
     }
   }
 
   return nullptr;
 }
 
 const RetainSummary *
 RetainSummaryManager::generateSummary(const FunctionDecl *FD,
                                       bool &AllowAnnotations) {
   // We generate "stop" summaries for implicitly defined functions.
   if (FD->isImplicit())
     return getPersistentStopSummary();
 
   const IdentifierInfo *II = FD->getIdentifier();
 
   StringRef FName = II ? II->getName() : "";
 
   // Strip away preceding '_'.  Doing this here will effect all the checks
   // down below.
   FName = FName.substr(FName.find_first_not_of('_'));
 
   // Inspect the result type. Strip away any typedefs.
   const auto *FT = FD->getType()->getAs<FunctionType>();
   QualType RetTy = FT->getReturnType();
 
   if (TrackOSObjects)
     if (const RetainSummary *S = getSummaryForOSObject(FD, FName, RetTy))
       return S;
 
   if (TrackObjCAndCFObjects)
     if (const RetainSummary *S =
             getSummaryForObjCOrCFObject(FD, FName, RetTy, FT, AllowAnnotations))
       return S;
 
   if (const auto *MD = dyn_cast<CXXMethodDecl>(FD))
     if (!(TrackOSObjects && isOSObjectRelated(MD)))
       return getPersistentSummary(RetEffect::MakeNoRet(),
                                   ArgEffects(AF.getEmptyMap()),
                                   ArgEffect(DoNothing),
                                   ArgEffect(StopTracking),
                                   ArgEffect(DoNothing));
 
   return getDefaultSummary();
 }
 
 const RetainSummary *
 RetainSummaryManager::getFunctionSummary(const FunctionDecl *FD) {
   // If we don't know what function we're calling, use our default summary.
   if (!FD)
     return getDefaultSummary();
 
   // Look up a summary in our cache of FunctionDecls -> Summaries.
   FuncSummariesTy::iterator I = FuncSummaries.find(FD);
   if (I != FuncSummaries.end())
     return I->second;
 
   // No summary?  Generate one.
   bool AllowAnnotations = true;
   const RetainSummary *S = generateSummary(FD, AllowAnnotations);
 
   // Annotations override defaults.
   if (AllowAnnotations)
     updateSummaryFromAnnotations(S, FD);
 
   FuncSummaries[FD] = S;
   return S;
 }
 
 //===----------------------------------------------------------------------===//
 // Summary creation for functions (largely uses of Core Foundation).
 //===----------------------------------------------------------------------===//
 
 static ArgEffect getStopTrackingHardEquivalent(ArgEffect E) {
   switch (E.getKind()) {
   case DoNothing:
   case Autorelease:
   case DecRefBridgedTransferred:
   case IncRef:
   case UnretainedOutParameter:
   case RetainedOutParameter:
   case RetainedOutParameterOnZero:
   case RetainedOutParameterOnNonZero:
   case MayEscape:
   case StopTracking:
   case StopTrackingHard:
     return E.withKind(StopTrackingHard);
   case DecRef:
   case DecRefAndStopTrackingHard:
     return E.withKind(DecRefAndStopTrackingHard);
   case Dealloc:
     return E.withKind(Dealloc);
   }
 
   llvm_unreachable("Unknown ArgEffect kind");
 }
 
 const RetainSummary *
 RetainSummaryManager::updateSummaryForNonZeroCallbackArg(const RetainSummary *S,
                                                          AnyCall &C) {
   ArgEffect RecEffect = getStopTrackingHardEquivalent(S->getReceiverEffect());
   ArgEffect DefEffect = getStopTrackingHardEquivalent(S->getDefaultArgEffect());
 
   ArgEffects ScratchArgs(AF.getEmptyMap());
   ArgEffects CustomArgEffects = S->getArgEffects();
   for (ArgEffects::iterator I = CustomArgEffects.begin(),
                             E = CustomArgEffects.end();
        I != E; ++I) {
     ArgEffect Translated = getStopTrackingHardEquivalent(I->second);
     if (Translated.getKind() != DefEffect.getKind())
       ScratchArgs = AF.add(ScratchArgs, I->first, Translated);
   }
 
   RetEffect RE = RetEffect::MakeNoRetHard();
 
   // Special cases where the callback argument CANNOT free the return value.
   // This can generally only happen if we know that the callback will only be
   // called when the return value is already being deallocated.
   if (const IdentifierInfo *Name = C.getIdentifier()) {
     // When the CGBitmapContext is deallocated, the callback here will free
     // the associated data buffer.
     // The callback in dispatch_data_create frees the buffer, but not
     // the data object.
     if (Name->isStr("CGBitmapContextCreateWithData") ||
         Name->isStr("dispatch_data_create"))
       RE = S->getRetEffect();
   }
 
   return getPersistentSummary(RE, ScratchArgs, RecEffect, DefEffect);
 }
 
 void RetainSummaryManager::updateSummaryForReceiverUnconsumedSelf(
     const RetainSummary *&S) {
 
   RetainSummaryTemplate Template(S, *this);
 
   Template->setReceiverEffect(ArgEffect(DoNothing));
   Template->setRetEffect(RetEffect::MakeNoRet());
 }
 
+
+void RetainSummaryManager::updateSummaryForArgumentTypes(
+  const AnyCall &C, const RetainSummary *&RS) {
+  RetainSummaryTemplate Template(RS, *this);
+
+  unsigned parm_idx = 0;
+  for (auto pi = C.param_begin(), pe = C.param_end(); pi != pe;
+       ++pi, ++parm_idx) {
+    QualType QT = (*pi)->getType();
+
+    // Skip already created values.
+    if (RS->getArgEffects().contains(parm_idx))
+      continue;
+
+    ObjKind K = ObjKind::AnyObj;
+
+    if (isISLObjectRef(QT)) {
+      K = ObjKind::Generalized;
+    } else if (isOSObjectPtr(QT)) {
+      K = ObjKind::OS;
+    } else if (cocoa::isCocoaObjectRef(QT)) {
+      K = ObjKind::ObjC;
+    } else if (coreFoundation::isCFObjectRef(QT)) {
+      K = ObjKind::CF;
+    }
+
+    if (K != ObjKind::AnyObj)
+      Template->addArg(AF, parm_idx,
+                       ArgEffect(RS->getDefaultArgEffect().getKind(), K));
+  }
+}
+
 const RetainSummary *
 RetainSummaryManager::getSummary(AnyCall C,
                                  bool HasNonZeroCallbackArg,
                                  bool IsReceiverUnconsumedSelf,
                                  QualType ReceiverType) {
   const RetainSummary *Summ;
   switch (C.getKind()) {
   case AnyCall::Function:
   case AnyCall::Constructor:
   case AnyCall::Allocator:
   case AnyCall::Deallocator:
     Summ = getFunctionSummary(cast_or_null<FunctionDecl>(C.getDecl()));
     break;
   case AnyCall::Block:
   case AnyCall::Destructor:
     // FIXME: These calls are currently unsupported.
     return getPersistentStopSummary();
   case AnyCall::ObjCMethod: {
     const auto *ME = cast_or_null<ObjCMessageExpr>(C.getExpr());
     if (!ME) {
       return getMethodSummary(cast<ObjCMethodDecl>(C.getDecl()));
     } else if (ME->isInstanceMessage()) {
       Summ = getInstanceMethodSummary(ME, ReceiverType);
     } else {
       Summ = getClassMethodSummary(ME);
     }
     break;
   }
   }
 
   if (HasNonZeroCallbackArg)
     Summ = updateSummaryForNonZeroCallbackArg(Summ, C);
 
   if (IsReceiverUnconsumedSelf)
     updateSummaryForReceiverUnconsumedSelf(Summ);
 
+  updateSummaryForArgumentTypes(C, Summ);
+
   assert(Summ && "Unknown call type?");
   return Summ;
 }
 
 
 const RetainSummary *
 RetainSummaryManager::getCFCreateGetRuleSummary(const FunctionDecl *FD) {
   if (coreFoundation::followsCreateRule(FD))
     return getCFSummaryCreateRule(FD);
 
   return getCFSummaryGetRule(FD);
 }
 
 bool RetainSummaryManager::isTrustedReferenceCountImplementation(
     const FunctionDecl *FD) {
   return hasRCAnnotation(FD, "rc_ownership_trusted_implementation");
 }
 
 Optional<RetainSummaryManager::BehaviorSummary>
 RetainSummaryManager::canEval(const CallExpr *CE, const FunctionDecl *FD,
                               bool &hasTrustedImplementationAnnotation) {
 
   IdentifierInfo *II = FD->getIdentifier();
   if (!II)
     return None;
 
   StringRef FName = II->getName();
   FName = FName.substr(FName.find_first_not_of('_'));
 
   QualType ResultTy = CE->getCallReturnType(Ctx);
   if (ResultTy->isObjCIdType()) {
     if (II->isStr("NSMakeCollectable"))
       return BehaviorSummary::Identity;
   } else if (ResultTy->isPointerType()) {
     // Handle: (CF|CG|CV)Retain
     //         CFAutorelease
     // It's okay to be a little sloppy here.
     if (FName == "CMBufferQueueDequeueAndRetain" ||
         FName == "CMBufferQueueDequeueIfDataReadyAndRetain") {
       // Part of: <rdar://problem/39390714>.
       // These are not retain. They just return something and retain it.
       return None;
     }
     if (cocoa::isRefType(ResultTy, "CF", FName) ||
         cocoa::isRefType(ResultTy, "CG", FName) ||
         cocoa::isRefType(ResultTy, "CV", FName))
       if (isRetain(FD, FName) || isAutorelease(FD, FName) ||
           isMakeCollectable(FName))
         return BehaviorSummary::Identity;
 
     // safeMetaCast is called by OSDynamicCast.
     // We assume that OSDynamicCast is either an identity (cast is OK,
     // the input was non-zero),
     // or that it returns zero (when the cast failed, or the input
     // was zero).
     if (TrackOSObjects) {
       if (isOSObjectDynamicCast(FName) && FD->param_size() >= 1) {
         return BehaviorSummary::IdentityOrZero;
       } else if (isOSObjectThisCast(FName) && isa<CXXMethodDecl>(FD) &&
                  !cast<CXXMethodDecl>(FD)->isStatic()) {
         return BehaviorSummary::IdentityThis;
       }
     }
 
     const FunctionDecl* FDD = FD->getDefinition();
     if (FDD && isTrustedReferenceCountImplementation(FDD)) {
       hasTrustedImplementationAnnotation = true;
       return BehaviorSummary::Identity;
     }
   }
 
   if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
     const CXXRecordDecl *Parent = MD->getParent();
     if (TrackOSObjects && Parent && isOSObjectSubclass(Parent))
       if (FName == "release" || FName == "retain")
         return BehaviorSummary::NoOp;
   }
 
   return None;
 }
 
 const RetainSummary *
 RetainSummaryManager::getUnarySummary(const FunctionType* FT,
                                       ArgEffectKind AE) {
 
   // Unary functions have no arg effects by definition.
   ArgEffects ScratchArgs(AF.getEmptyMap());
 
   // Sanity check that this is *really* a unary function.  This can
   // happen if people do weird things.
   const FunctionProtoType* FTP = dyn_cast<FunctionProtoType>(FT);
   if (!FTP || FTP->getNumParams() != 1)
     return getPersistentStopSummary();
 
   ArgEffect Effect(AE, ObjKind::CF);
 
   ScratchArgs = AF.add(ScratchArgs, 0, Effect);
   return getPersistentSummary(RetEffect::MakeNoRet(),
                               ScratchArgs,
                               ArgEffect(DoNothing), ArgEffect(DoNothing));
 }
 
 const RetainSummary *
 RetainSummaryManager::getOSSummaryRetainRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeNoRet(),
                               AF.getEmptyMap(),
                               /*ReceiverEff=*/ArgEffect(DoNothing),
                               /*DefaultEff=*/ArgEffect(DoNothing),
                               /*ThisEff=*/ArgEffect(IncRef, ObjKind::OS));
 }
 
 const RetainSummary *
 RetainSummaryManager::getOSSummaryReleaseRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeNoRet(),
                               AF.getEmptyMap(),
                               /*ReceiverEff=*/ArgEffect(DoNothing),
                               /*DefaultEff=*/ArgEffect(DoNothing),
                               /*ThisEff=*/ArgEffect(DecRef, ObjKind::OS));
 }
 
 const RetainSummary *
 RetainSummaryManager::getOSSummaryFreeRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeNoRet(),
                               AF.getEmptyMap(),
                               /*ReceiverEff=*/ArgEffect(DoNothing),
                               /*DefaultEff=*/ArgEffect(DoNothing),
                               /*ThisEff=*/ArgEffect(Dealloc, ObjKind::OS));
 }
 
 const RetainSummary *
 RetainSummaryManager::getOSSummaryCreateRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeOwned(ObjKind::OS),
                               AF.getEmptyMap());
 }
 
 const RetainSummary *
 RetainSummaryManager::getOSSummaryGetRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeNotOwned(ObjKind::OS),
                               AF.getEmptyMap());
 }
 
 const RetainSummary *
 RetainSummaryManager::getCFSummaryCreateRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeOwned(ObjKind::CF),
                               ArgEffects(AF.getEmptyMap()));
 }
 
 const RetainSummary *
 RetainSummaryManager::getCFSummaryGetRule(const FunctionDecl *FD) {
   return getPersistentSummary(RetEffect::MakeNotOwned(ObjKind::CF),
                               ArgEffects(AF.getEmptyMap()),
                               ArgEffect(DoNothing), ArgEffect(DoNothing));
 }
 
 
 
 
 //===----------------------------------------------------------------------===//
 // Summary creation for Selectors.
 //===----------------------------------------------------------------------===//
 
 Optional<RetEffect>
 RetainSummaryManager::getRetEffectFromAnnotations(QualType RetTy,
                                                   const Decl *D) {
   if (hasAnyEnabledAttrOf<NSReturnsRetainedAttr>(D, RetTy))
     return ObjCAllocRetE;
 
   if (auto K = hasAnyEnabledAttrOf<CFReturnsRetainedAttr, OSReturnsRetainedAttr,
                                    GeneralizedReturnsRetainedAttr>(D, RetTy))
     return RetEffect::MakeOwned(*K);
 
   if (auto K = hasAnyEnabledAttrOf<
           CFReturnsNotRetainedAttr, OSReturnsNotRetainedAttr,
           GeneralizedReturnsNotRetainedAttr, NSReturnsNotRetainedAttr,
           NSReturnsAutoreleasedAttr>(D, RetTy))
     return RetEffect::MakeNotOwned(*K);
 
   if (const auto *MD = dyn_cast<CXXMethodDecl>(D))
     for (const auto *PD : MD->overridden_methods())
       if (auto RE = getRetEffectFromAnnotations(RetTy, PD))
         return RE;
 
   return None;
 }
 
 /// \return Whether the chain of typedefs starting from {@code QT}
 /// has a typedef with a given name {@code Name}.
 static bool hasTypedefNamed(QualType QT,
                             StringRef Name) {
   while (auto *T = dyn_cast<TypedefType>(QT)) {
     const auto &Context = T->getDecl()->getASTContext();
     if (T->getDecl()->getIdentifier() == &Context.Idents.get(Name))
       return true;
     QT = T->getDecl()->getUnderlyingType();
   }
   return false;
 }
 
 static QualType getCallableReturnType(const NamedDecl *ND) {
   if (const auto *FD = dyn_cast<FunctionDecl>(ND)) {
     return FD->getReturnType();
   } else if (const auto *MD = dyn_cast<ObjCMethodDecl>(ND)) {
     return MD->getReturnType();
   } else {
     llvm_unreachable("Unexpected decl");
   }
 }
 
 bool RetainSummaryManager::applyParamAnnotationEffect(
     const ParmVarDecl *pd, unsigned parm_idx, const NamedDecl *FD,
     RetainSummaryTemplate &Template) {
   QualType QT = pd->getType();
   if (auto K =
           hasAnyEnabledAttrOf<NSConsumedAttr, CFConsumedAttr, OSConsumedAttr,
                               GeneralizedConsumedAttr>(pd, QT)) {
     Template->addArg(AF, parm_idx, ArgEffect(DecRef, *K));
     return true;
   } else if (auto K = hasAnyEnabledAttrOf<
                  CFReturnsRetainedAttr, OSReturnsRetainedAttr,
                  OSReturnsRetainedOnNonZeroAttr, OSReturnsRetainedOnZeroAttr,
                  GeneralizedReturnsRetainedAttr>(pd, QT)) {
 
     // For OSObjects, we try to guess whether the object is created based
     // on the return value.
     if (K == ObjKind::OS) {
       QualType QT = getCallableReturnType(FD);
 
       bool HasRetainedOnZero = pd->hasAttr<OSReturnsRetainedOnZeroAttr>();
       bool HasRetainedOnNonZero = pd->hasAttr<OSReturnsRetainedOnNonZeroAttr>();
 
       // The usual convention is to create an object on non-zero return, but
       // it's reverted if the typedef chain has a typedef kern_return_t,
       // because kReturnSuccess constant is defined as zero.
       // The convention can be overwritten by custom attributes.
       bool SuccessOnZero =
           HasRetainedOnZero ||
           (hasTypedefNamed(QT, "kern_return_t") && !HasRetainedOnNonZero);
       bool ShouldSplit = !QT.isNull() && !QT->isVoidType();
       ArgEffectKind AK = RetainedOutParameter;
       if (ShouldSplit && SuccessOnZero) {
         AK = RetainedOutParameterOnZero;
       } else if (ShouldSplit && (!SuccessOnZero || HasRetainedOnNonZero)) {
         AK = RetainedOutParameterOnNonZero;
       }
       Template->addArg(AF, parm_idx, ArgEffect(AK, ObjKind::OS));
     }
 
     // For others:
     // Do nothing. Retained out parameters will either point to a +1 reference
     // or NULL, but the way you check for failure differs depending on the
     // API. Consequently, we don't have a good way to track them yet.
     return true;
   } else if (auto K = hasAnyEnabledAttrOf<CFReturnsNotRetainedAttr,
                                           OSReturnsNotRetainedAttr,
                                           GeneralizedReturnsNotRetainedAttr>(
                  pd, QT)) {
     Template->addArg(AF, parm_idx, ArgEffect(UnretainedOutParameter, *K));
     return true;
   }
 
   if (const auto *MD = dyn_cast<CXXMethodDecl>(FD)) {
     for (const auto *OD : MD->overridden_methods()) {
       const ParmVarDecl *OP = OD->parameters()[parm_idx];
       if (applyParamAnnotationEffect(OP, parm_idx, OD, Template))
         return true;
     }
   }
 
   return false;
 }
 
 void
 RetainSummaryManager::updateSummaryFromAnnotations(const RetainSummary *&Summ,
                                                    const FunctionDecl *FD) {
   if (!FD)
     return;
 
   assert(Summ && "Must have a summary to add annotations to.");
   RetainSummaryTemplate Template(Summ, *this);
 
   // Effects on the parameters.
   unsigned parm_idx = 0;
   for (auto pi = FD->param_begin(),
          pe = FD->param_end(); pi != pe; ++pi, ++parm_idx)
     applyParamAnnotationEffect(*pi, parm_idx, FD, Template);
 
   QualType RetTy = FD->getReturnType();
   if (Optional<RetEffect> RetE = getRetEffectFromAnnotations(RetTy, FD))
     Template->setRetEffect(*RetE);
 
   if (hasAnyEnabledAttrOf<OSConsumesThisAttr>(FD, RetTy))
     Template->setThisEffect(ArgEffect(DecRef, ObjKind::OS));
 }
 
 void
 RetainSummaryManager::updateSummaryFromAnnotations(const RetainSummary *&Summ,
                                                    const ObjCMethodDecl *MD) {
   if (!MD)
     return;
 
   assert(Summ && "Must have a valid summary to add annotations to");
   RetainSummaryTemplate Template(Summ, *this);
 
   // Effects on the receiver.
   if (hasAnyEnabledAttrOf<NSConsumesSelfAttr>(MD, MD->getReturnType()))
     Template->setReceiverEffect(ArgEffect(DecRef, ObjKind::ObjC));
 
   // Effects on the parameters.
   unsigned parm_idx = 0;
   for (auto pi = MD->param_begin(), pe = MD->param_end(); pi != pe;
        ++pi, ++parm_idx)
     applyParamAnnotationEffect(*pi, parm_idx, MD, Template);
 
   QualType RetTy = MD->getReturnType();
   if (Optional<RetEffect> RetE = getRetEffectFromAnnotations(RetTy, MD))
     Template->setRetEffect(*RetE);
 }
 
 const RetainSummary *
 RetainSummaryManager::getStandardMethodSummary(const ObjCMethodDecl *MD,
                                                Selector S, QualType RetTy) {
   // Any special effects?
   ArgEffect ReceiverEff = ArgEffect(DoNothing, ObjKind::ObjC);
   RetEffect ResultEff = RetEffect::MakeNoRet();
 
   // Check the method family, and apply any default annotations.
   switch (MD ? MD->getMethodFamily() : S.getMethodFamily()) {
     case OMF_None:
     case OMF_initialize:
     case OMF_performSelector:
       // Assume all Objective-C methods follow Cocoa Memory Management rules.
       // FIXME: Does the non-threaded performSelector family really belong here?
       // The selector could be, say, @selector(copy).
       if (cocoa::isCocoaObjectRef(RetTy))
         ResultEff = RetEffect::MakeNotOwned(ObjKind::ObjC);
       else if (coreFoundation::isCFObjectRef(RetTy)) {
         // ObjCMethodDecl currently doesn't consider CF objects as valid return
         // values for alloc, new, copy, or mutableCopy, so we have to
         // double-check with the selector. This is ugly, but there aren't that
         // many Objective-C methods that return CF objects, right?
         if (MD) {
           switch (S.getMethodFamily()) {
           case OMF_alloc:
           case OMF_new:
           case OMF_copy:
           case OMF_mutableCopy:
             ResultEff = RetEffect::MakeOwned(ObjKind::CF);
             break;
           default:
             ResultEff = RetEffect::MakeNotOwned(ObjKind::CF);
             break;
           }
         } else {
           ResultEff = RetEffect::MakeNotOwned(ObjKind::CF);
         }
       }
       break;
     case OMF_init:
       ResultEff = ObjCInitRetE;
       ReceiverEff = ArgEffect(DecRef, ObjKind::ObjC);
       break;
     case OMF_alloc:
     case OMF_new:
     case OMF_copy:
     case OMF_mutableCopy:
       if (cocoa::isCocoaObjectRef(RetTy))
         ResultEff = ObjCAllocRetE;
       else if (coreFoundation::isCFObjectRef(RetTy))
         ResultEff = RetEffect::MakeOwned(ObjKind::CF);
       break;
     case OMF_autorelease:
       ReceiverEff = ArgEffect(Autorelease, ObjKind::ObjC);
       break;
     case OMF_retain:
       ReceiverEff = ArgEffect(IncRef, ObjKind::ObjC);
       break;
     case OMF_release:
       ReceiverEff = ArgEffect(DecRef, ObjKind::ObjC);
       break;
     case OMF_dealloc:
       ReceiverEff = ArgEffect(Dealloc, ObjKind::ObjC);
       break;
     case OMF_self:
       // -self is handled specially by the ExprEngine to propagate the receiver.
       break;
     case OMF_retainCount:
     case OMF_finalize:
       // These methods don't return objects.
       break;
   }
 
   // If one of the arguments in the selector has the keyword 'delegate' we
   // should stop tracking the reference count for the receiver.  This is
   // because the reference count is quite possibly handled by a delegate
   // method.
   if (S.isKeywordSelector()) {
     for (unsigned i = 0, e = S.getNumArgs(); i != e; ++i) {
       StringRef Slot = S.getNameForSlot(i);
       if (Slot.substr(Slot.size() - 8).equals_lower("delegate")) {
         if (ResultEff == ObjCInitRetE)
           ResultEff = RetEffect::MakeNoRetHard();
         else
           ReceiverEff = ArgEffect(StopTrackingHard, ObjKind::ObjC);
       }
     }
   }
 
   if (ReceiverEff.getKind() == DoNothing &&
       ResultEff.getKind() == RetEffect::NoRet)
     return getDefaultSummary();
 
   return getPersistentSummary(ResultEff, ArgEffects(AF.getEmptyMap()),
                               ArgEffect(ReceiverEff), ArgEffect(MayEscape));
 }
 
 const RetainSummary *
 RetainSummaryManager::getClassMethodSummary(const ObjCMessageExpr *ME) {
   assert(!ME->isInstanceMessage());
   const ObjCInterfaceDecl *Class = ME->getReceiverInterface();
 
   return getMethodSummary(ME->getSelector(), Class, ME->getMethodDecl(),
                           ME->getType(), ObjCClassMethodSummaries);
 }
 
 const RetainSummary *RetainSummaryManager::getInstanceMethodSummary(
     const ObjCMessageExpr *ME,
     QualType ReceiverType) {
   const ObjCInterfaceDecl *ReceiverClass = nullptr;
 
   // We do better tracking of the type of the object than the core ExprEngine.
   // See if we have its type in our private state.
   if (!ReceiverType.isNull())
     if (const auto *PT = ReceiverType->getAs<ObjCObjectPointerType>())
       ReceiverClass = PT->getInterfaceDecl();
 
   // If we don't know what kind of object this is, fall back to its static type.
   if (!ReceiverClass)
     ReceiverClass = ME->getReceiverInterface();
 
   // FIXME: The receiver could be a reference to a class, meaning that
   //  we should use the class method.
   // id x = [NSObject class];
   // [x performSelector:... withObject:... afterDelay:...];
   Selector S = ME->getSelector();
   const ObjCMethodDecl *Method = ME->getMethodDecl();
   if (!Method && ReceiverClass)
     Method = ReceiverClass->getInstanceMethod(S);
 
   return getMethodSummary(S, ReceiverClass, Method, ME->getType(),
                           ObjCMethodSummaries);
 }
 
 const RetainSummary *
 RetainSummaryManager::getMethodSummary(Selector S,
                                        const ObjCInterfaceDecl *ID,
                                        const ObjCMethodDecl *MD, QualType RetTy,
                                        ObjCMethodSummariesTy &CachedSummaries) {
 
   // Objective-C method summaries are only applicable to ObjC and CF objects.
   if (!TrackObjCAndCFObjects)
     return getDefaultSummary();
 
   // Look up a summary in our summary cache.
   const RetainSummary *Summ = CachedSummaries.find(ID, S);
 
   if (!Summ) {
     Summ = getStandardMethodSummary(MD, S, RetTy);
 
     // Annotations override defaults.
     updateSummaryFromAnnotations(Summ, MD);
 
     // Memoize the summary.
     CachedSummaries[ObjCSummaryKey(ID, S)] = Summ;
   }
 
   return Summ;
 }
 
 void RetainSummaryManager::InitializeClassMethodSummaries() {
   ArgEffects ScratchArgs = AF.getEmptyMap();
 
   // Create the [NSAssertionHandler currentHander] summary.
   addClassMethSummary("NSAssertionHandler", "currentHandler",
                 getPersistentSummary(RetEffect::MakeNotOwned(ObjKind::ObjC),
                                      ScratchArgs));
 
   // Create the [NSAutoreleasePool addObject:] summary.
   ScratchArgs = AF.add(ScratchArgs, 0, ArgEffect(Autorelease));
   addClassMethSummary("NSAutoreleasePool", "addObject",
                       getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
                                            ArgEffect(DoNothing),
                                            ArgEffect(Autorelease)));
 }
 
 void RetainSummaryManager::InitializeMethodSummaries() {
 
   ArgEffects ScratchArgs = AF.getEmptyMap();
   // Create the "init" selector.  It just acts as a pass-through for the
   // receiver.
   const RetainSummary *InitSumm = getPersistentSummary(
       ObjCInitRetE, ScratchArgs, ArgEffect(DecRef, ObjKind::ObjC));
   addNSObjectMethSummary(GetNullarySelector("init", Ctx), InitSumm);
 
   // awakeAfterUsingCoder: behaves basically like an 'init' method.  It
   // claims the receiver and returns a retained object.
   addNSObjectMethSummary(GetUnarySelector("awakeAfterUsingCoder", Ctx),
                          InitSumm);
 
   // The next methods are allocators.
   const RetainSummary *AllocSumm = getPersistentSummary(ObjCAllocRetE,
                                                         ScratchArgs);
   const RetainSummary *CFAllocSumm =
     getPersistentSummary(RetEffect::MakeOwned(ObjKind::CF), ScratchArgs);
 
   // Create the "retain" selector.
   RetEffect NoRet = RetEffect::MakeNoRet();
   const RetainSummary *Summ = getPersistentSummary(
       NoRet, ScratchArgs, ArgEffect(IncRef, ObjKind::ObjC));
   addNSObjectMethSummary(GetNullarySelector("retain", Ctx), Summ);
 
   // Create the "release" selector.
   Summ = getPersistentSummary(NoRet, ScratchArgs,
                               ArgEffect(DecRef, ObjKind::ObjC));
   addNSObjectMethSummary(GetNullarySelector("release", Ctx), Summ);
 
   // Create the -dealloc summary.
   Summ = getPersistentSummary(NoRet, ScratchArgs, ArgEffect(Dealloc,
                                                             ObjKind::ObjC));
   addNSObjectMethSummary(GetNullarySelector("dealloc", Ctx), Summ);
 
   // Create the "autorelease" selector.
   Summ = getPersistentSummary(NoRet, ScratchArgs, ArgEffect(Autorelease,
                                                             ObjKind::ObjC));
   addNSObjectMethSummary(GetNullarySelector("autorelease", Ctx), Summ);
 
   // For NSWindow, allocated objects are (initially) self-owned.
   // FIXME: For now we opt for false negatives with NSWindow, as these objects
   //  self-own themselves.  However, they only do this once they are displayed.
   //  Thus, we need to track an NSWindow's display status.
   //  This is tracked in <rdar://problem/6062711>.
   //  See also http://llvm.org/bugs/show_bug.cgi?id=3714.
   const RetainSummary *NoTrackYet =
       getPersistentSummary(RetEffect::MakeNoRet(), ScratchArgs,
                            ArgEffect(StopTracking), ArgEffect(StopTracking));
 
   addClassMethSummary("NSWindow", "alloc", NoTrackYet);
 
   // For NSPanel (which subclasses NSWindow), allocated objects are not
   //  self-owned.
   // FIXME: For now we don't track NSPanels. object for the same reason
   //   as for NSWindow objects.
   addClassMethSummary("NSPanel", "alloc", NoTrackYet);
 
   // For NSNull, objects returned by +null are singletons that ignore
   // retain/release semantics.  Just don't track them.
   // <rdar://problem/12858915>
   addClassMethSummary("NSNull", "null", NoTrackYet);
 
   // Don't track allocated autorelease pools, as it is okay to prematurely
   // exit a method.
   addClassMethSummary("NSAutoreleasePool", "alloc", NoTrackYet);
   addClassMethSummary("NSAutoreleasePool", "allocWithZone", NoTrackYet, false);
   addClassMethSummary("NSAutoreleasePool", "new", NoTrackYet);
 
   // Create summaries QCRenderer/QCView -createSnapShotImageOfType:
   addInstMethSummary("QCRenderer", AllocSumm, "createSnapshotImageOfType");
   addInstMethSummary("QCView", AllocSumm, "createSnapshotImageOfType");
 
   // Create summaries for CIContext, 'createCGImage' and
   // 'createCGLayerWithSize'.  These objects are CF objects, and are not
   // automatically garbage collected.
   addInstMethSummary("CIContext", CFAllocSumm, "createCGImage", "fromRect");
   addInstMethSummary("CIContext", CFAllocSumm, "createCGImage", "fromRect",
                      "format", "colorSpace");
   addInstMethSummary("CIContext", CFAllocSumm, "createCGLayerWithSize", "info");
 }
 
 const RetainSummary *
 RetainSummaryManager::getMethodSummary(const ObjCMethodDecl *MD) {
   const ObjCInterfaceDecl *ID = MD->getClassInterface();
   Selector S = MD->getSelector();
   QualType ResultTy = MD->getReturnType();
 
   ObjCMethodSummariesTy *CachedSummaries;
   if (MD->isInstanceMethod())
     CachedSummaries = &ObjCMethodSummaries;
   else
     CachedSummaries = &ObjCClassMethodSummaries;
 
   return getMethodSummary(S, ID, MD, ResultTy, *CachedSummaries);
 }
diff --git a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp
index b55ea2a116e8..18de1de78459 100644
--- a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.cpp
@@ -1,1494 +1,1499 @@
 //==-- RetainCountChecker.cpp - Checks for leaks and other issues -*- C++ -*--//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the methods for RetainCountChecker, which implements
 //  a reference count checker for Core Foundation and Cocoa on (Mac OS X).
 //
 //===----------------------------------------------------------------------===//
 
 #include "RetainCountChecker.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 
 using namespace clang;
 using namespace ento;
 using namespace retaincountchecker;
 using llvm::StrInStrNoCase;
 
 REGISTER_MAP_WITH_PROGRAMSTATE(RefBindings, SymbolRef, RefVal)
 
 namespace clang {
 namespace ento {
 namespace retaincountchecker {
 
 const RefVal *getRefBinding(ProgramStateRef State, SymbolRef Sym) {
   return State->get<RefBindings>(Sym);
 }
 
 } // end namespace retaincountchecker
 } // end namespace ento
 } // end namespace clang
 
 static ProgramStateRef setRefBinding(ProgramStateRef State, SymbolRef Sym,
                                      RefVal Val) {
   assert(Sym != nullptr);
   return State->set<RefBindings>(Sym, Val);
 }
 
 static ProgramStateRef removeRefBinding(ProgramStateRef State, SymbolRef Sym) {
   return State->remove<RefBindings>(Sym);
 }
 
 void RefVal::print(raw_ostream &Out) const {
   if (!T.isNull())
     Out << "Tracked " << T.getAsString() << " | ";
 
   switch (getKind()) {
     default: llvm_unreachable("Invalid RefVal kind");
     case Owned: {
       Out << "Owned";
       unsigned cnt = getCount();
       if (cnt) Out << " (+ " << cnt << ")";
       break;
     }
 
     case NotOwned: {
       Out << "NotOwned";
       unsigned cnt = getCount();
       if (cnt) Out << " (+ " << cnt << ")";
       break;
     }
 
     case ReturnedOwned: {
       Out << "ReturnedOwned";
       unsigned cnt = getCount();
       if (cnt) Out << " (+ " << cnt << ")";
       break;
     }
 
     case ReturnedNotOwned: {
       Out << "ReturnedNotOwned";
       unsigned cnt = getCount();
       if (cnt) Out << " (+ " << cnt << ")";
       break;
     }
 
     case Released:
       Out << "Released";
       break;
 
     case ErrorDeallocNotOwned:
       Out << "-dealloc (not-owned)";
       break;
 
     case ErrorLeak:
       Out << "Leaked";
       break;
 
     case ErrorLeakReturned:
       Out << "Leaked (Bad naming)";
       break;
 
     case ErrorUseAfterRelease:
       Out << "Use-After-Release [ERROR]";
       break;
 
     case ErrorReleaseNotOwned:
       Out << "Release of Not-Owned [ERROR]";
       break;
 
     case RefVal::ErrorOverAutorelease:
       Out << "Over-autoreleased";
       break;
 
     case RefVal::ErrorReturnedNotOwned:
       Out << "Non-owned object returned instead of owned";
       break;
   }
 
   switch (getIvarAccessHistory()) {
   case IvarAccessHistory::None:
     break;
   case IvarAccessHistory::AccessedDirectly:
     Out << " [direct ivar access]";
     break;
   case IvarAccessHistory::ReleasedAfterDirectAccess:
     Out << " [released after direct ivar access]";
   }
 
   if (ACnt) {
     Out << " [autorelease -" << ACnt << ']';
   }
 }
 
 namespace {
 class StopTrackingCallback final : public SymbolVisitor {
   ProgramStateRef state;
 public:
   StopTrackingCallback(ProgramStateRef st) : state(std::move(st)) {}
   ProgramStateRef getState() const { return state; }
 
   bool VisitSymbol(SymbolRef sym) override {
     state = removeRefBinding(state, sym);
     return true;
   }
 };
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // Handle statements that may have an effect on refcounts.
 //===----------------------------------------------------------------------===//
 
 void RetainCountChecker::checkPostStmt(const BlockExpr *BE,
                                        CheckerContext &C) const {
 
   // Scan the BlockDecRefExprs for any object the retain count checker
   // may be tracking.
   if (!BE->getBlockDecl()->hasCaptures())
     return;
 
   ProgramStateRef state = C.getState();
   auto *R = cast<BlockDataRegion>(C.getSVal(BE).getAsRegion());
 
   BlockDataRegion::referenced_vars_iterator I = R->referenced_vars_begin(),
                                             E = R->referenced_vars_end();
 
   if (I == E)
     return;
 
   // FIXME: For now we invalidate the tracking of all symbols passed to blocks
   // via captured variables, even though captured variables result in a copy
   // and in implicit increment/decrement of a retain count.
   SmallVector<const MemRegion*, 10> Regions;
   const LocationContext *LC = C.getLocationContext();
   MemRegionManager &MemMgr = C.getSValBuilder().getRegionManager();
 
   for ( ; I != E; ++I) {
     const VarRegion *VR = I.getCapturedRegion();
     if (VR->getSuperRegion() == R) {
       VR = MemMgr.getVarRegion(VR->getDecl(), LC);
     }
     Regions.push_back(VR);
   }
 
   state = state->scanReachableSymbols<StopTrackingCallback>(Regions).getState();
   C.addTransition(state);
 }
 
 void RetainCountChecker::checkPostStmt(const CastExpr *CE,
                                        CheckerContext &C) const {
   const ObjCBridgedCastExpr *BE = dyn_cast<ObjCBridgedCastExpr>(CE);
   if (!BE)
     return;
 
   ArgEffect AE = ArgEffect(IncRef, ObjKind::ObjC);
 
   switch (BE->getBridgeKind()) {
     case OBC_Bridge:
       // Do nothing.
       return;
     case OBC_BridgeRetained:
       AE = AE.withKind(IncRef);
       break;
     case OBC_BridgeTransfer:
       AE = AE.withKind(DecRefBridgedTransferred);
       break;
   }
 
   ProgramStateRef state = C.getState();
   SymbolRef Sym = C.getSVal(CE).getAsLocSymbol();
   if (!Sym)
     return;
   const RefVal* T = getRefBinding(state, Sym);
   if (!T)
     return;
 
   RefVal::Kind hasErr = (RefVal::Kind) 0;
   state = updateSymbol(state, Sym, *T, AE, hasErr, C);
 
   if (hasErr) {
     // FIXME: If we get an error during a bridge cast, should we report it?
     return;
   }
 
   C.addTransition(state);
 }
 
 void RetainCountChecker::processObjCLiterals(CheckerContext &C,
                                              const Expr *Ex) const {
   ProgramStateRef state = C.getState();
   const ExplodedNode *pred = C.getPredecessor();
   for (const Stmt *Child : Ex->children()) {
     SVal V = pred->getSVal(Child);
     if (SymbolRef sym = V.getAsSymbol())
       if (const RefVal* T = getRefBinding(state, sym)) {
         RefVal::Kind hasErr = (RefVal::Kind) 0;
         state = updateSymbol(state, sym, *T,
                              ArgEffect(MayEscape, ObjKind::ObjC), hasErr, C);
         if (hasErr) {
           processNonLeakError(state, Child->getSourceRange(), hasErr, sym, C);
           return;
         }
       }
   }
 
   // Return the object as autoreleased.
   //  RetEffect RE = RetEffect::MakeNotOwned(ObjKind::ObjC);
   if (SymbolRef sym =
         state->getSVal(Ex, pred->getLocationContext()).getAsSymbol()) {
     QualType ResultTy = Ex->getType();
     state = setRefBinding(state, sym,
                           RefVal::makeNotOwned(ObjKind::ObjC, ResultTy));
   }
 
   C.addTransition(state);
 }
 
 void RetainCountChecker::checkPostStmt(const ObjCArrayLiteral *AL,
                                        CheckerContext &C) const {
   // Apply the 'MayEscape' to all values.
   processObjCLiterals(C, AL);
 }
 
 void RetainCountChecker::checkPostStmt(const ObjCDictionaryLiteral *DL,
                                        CheckerContext &C) const {
   // Apply the 'MayEscape' to all keys and values.
   processObjCLiterals(C, DL);
 }
 
 void RetainCountChecker::checkPostStmt(const ObjCBoxedExpr *Ex,
                                        CheckerContext &C) const {
   const ExplodedNode *Pred = C.getPredecessor();
   ProgramStateRef State = Pred->getState();
 
   if (SymbolRef Sym = Pred->getSVal(Ex).getAsSymbol()) {
     QualType ResultTy = Ex->getType();
     State = setRefBinding(State, Sym,
                           RefVal::makeNotOwned(ObjKind::ObjC, ResultTy));
   }
 
   C.addTransition(State);
 }
 
 void RetainCountChecker::checkPostStmt(const ObjCIvarRefExpr *IRE,
                                        CheckerContext &C) const {
   Optional<Loc> IVarLoc = C.getSVal(IRE).getAs<Loc>();
   if (!IVarLoc)
     return;
 
   ProgramStateRef State = C.getState();
   SymbolRef Sym = State->getSVal(*IVarLoc).getAsSymbol();
   if (!Sym || !dyn_cast_or_null<ObjCIvarRegion>(Sym->getOriginRegion()))
     return;
 
   // Accessing an ivar directly is unusual. If we've done that, be more
   // forgiving about what the surrounding code is allowed to do.
 
   QualType Ty = Sym->getType();
   ObjKind Kind;
   if (Ty->isObjCRetainableType())
     Kind = ObjKind::ObjC;
   else if (coreFoundation::isCFObjectRef(Ty))
     Kind = ObjKind::CF;
   else
     return;
 
   // If the value is already known to be nil, don't bother tracking it.
   ConstraintManager &CMgr = State->getConstraintManager();
   if (CMgr.isNull(State, Sym).isConstrainedTrue())
     return;
 
   if (const RefVal *RV = getRefBinding(State, Sym)) {
     // If we've seen this symbol before, or we're only seeing it now because
     // of something the analyzer has synthesized, don't do anything.
     if (RV->getIvarAccessHistory() != RefVal::IvarAccessHistory::None ||
         isSynthesizedAccessor(C.getStackFrame())) {
       return;
     }
 
     // Note that this value has been loaded from an ivar.
     C.addTransition(setRefBinding(State, Sym, RV->withIvarAccess()));
     return;
   }
 
   RefVal PlusZero = RefVal::makeNotOwned(Kind, Ty);
 
   // In a synthesized accessor, the effective retain count is +0.
   if (isSynthesizedAccessor(C.getStackFrame())) {
     C.addTransition(setRefBinding(State, Sym, PlusZero));
     return;
   }
 
   State = setRefBinding(State, Sym, PlusZero.withIvarAccess());
   C.addTransition(State);
 }
 
 static bool isReceiverUnconsumedSelf(const CallEvent &Call) {
   if (const auto *MC = dyn_cast<ObjCMethodCall>(&Call)) {
 
     // Check if the message is not consumed, we know it will not be used in
     // an assignment, ex: "self = [super init]".
     return MC->getMethodFamily() == OMF_init && MC->isReceiverSelfOrSuper() &&
            !Call.getLocationContext()
                 ->getAnalysisDeclContext()
                 ->getParentMap()
                 .isConsumedExpr(Call.getOriginExpr());
   }
   return false;
 }
 
 const static RetainSummary *getSummary(RetainSummaryManager &Summaries,
                                        const CallEvent &Call,
                                        QualType ReceiverType) {
   const Expr *CE = Call.getOriginExpr();
   AnyCall C =
       CE ? *AnyCall::forExpr(CE)
          : AnyCall(cast<CXXDestructorDecl>(Call.getDecl()));
   return Summaries.getSummary(C, Call.hasNonZeroCallbackArg(),
                               isReceiverUnconsumedSelf(Call), ReceiverType);
 }
 
 void RetainCountChecker::checkPostCall(const CallEvent &Call,
                                        CheckerContext &C) const {
   RetainSummaryManager &Summaries = getSummaryManager(C);
 
   // Leave null if no receiver.
   QualType ReceiverType;
   if (const auto *MC = dyn_cast<ObjCMethodCall>(&Call)) {
     if (MC->isInstanceMessage()) {
       SVal ReceiverV = MC->getReceiverSVal();
       if (SymbolRef Sym = ReceiverV.getAsLocSymbol())
         if (const RefVal *T = getRefBinding(C.getState(), Sym))
           ReceiverType = T->getType();
     }
   }
 
   const RetainSummary *Summ = getSummary(Summaries, Call, ReceiverType);
 
   if (C.wasInlined) {
     processSummaryOfInlined(*Summ, Call, C);
     return;
   }
   checkSummary(*Summ, Call, C);
 }
 
 /// GetReturnType - Used to get the return type of a message expression or
 ///  function call with the intention of affixing that type to a tracked symbol.
 ///  While the return type can be queried directly from RetEx, when
 ///  invoking class methods we augment to the return type to be that of
 ///  a pointer to the class (as opposed it just being id).
 // FIXME: We may be able to do this with related result types instead.
 // This function is probably overestimating.
 static QualType GetReturnType(const Expr *RetE, ASTContext &Ctx) {
   QualType RetTy = RetE->getType();
   // If RetE is not a message expression just return its type.
   // If RetE is a message expression, return its types if it is something
   /// more specific than id.
   if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(RetE))
     if (const ObjCObjectPointerType *PT = RetTy->getAs<ObjCObjectPointerType>())
       if (PT->isObjCQualifiedIdType() || PT->isObjCIdType() ||
           PT->isObjCClassType()) {
         // At this point we know the return type of the message expression is
         // id, id<...>, or Class. If we have an ObjCInterfaceDecl, we know this
         // is a call to a class method whose type we can resolve.  In such
         // cases, promote the return type to XXX* (where XXX is the class).
         const ObjCInterfaceDecl *D = ME->getReceiverInterface();
         return !D ? RetTy :
                     Ctx.getObjCObjectPointerType(Ctx.getObjCInterfaceType(D));
       }
 
   return RetTy;
 }
 
 static Optional<RefVal> refValFromRetEffect(RetEffect RE,
                                             QualType ResultTy) {
   if (RE.isOwned()) {
     return RefVal::makeOwned(RE.getObjKind(), ResultTy);
   } else if (RE.notOwned()) {
     return RefVal::makeNotOwned(RE.getObjKind(), ResultTy);
   }
 
   return None;
 }
 
 static bool isPointerToObject(QualType QT) {
   QualType PT = QT->getPointeeType();
   if (!PT.isNull())
     if (PT->getAsCXXRecordDecl())
       return true;
   return false;
 }
 
 /// Whether the tracked value should be escaped on a given call.
 /// OSObjects are escaped when passed to void * / etc.
 static bool shouldEscapeOSArgumentOnCall(const CallEvent &CE, unsigned ArgIdx,
                                        const RefVal *TrackedValue) {
   if (TrackedValue->getObjKind() != ObjKind::OS)
     return false;
   if (ArgIdx >= CE.parameters().size())
     return false;
   return !isPointerToObject(CE.parameters()[ArgIdx]->getType());
 }
 
 // We don't always get the exact modeling of the function with regards to the
 // retain count checker even when the function is inlined. For example, we need
 // to stop tracking the symbols which were marked with StopTrackingHard.
 void RetainCountChecker::processSummaryOfInlined(const RetainSummary &Summ,
                                                  const CallEvent &CallOrMsg,
                                                  CheckerContext &C) const {
   ProgramStateRef state = C.getState();
 
   // Evaluate the effect of the arguments.
   for (unsigned idx = 0, e = CallOrMsg.getNumArgs(); idx != e; ++idx) {
     SVal V = CallOrMsg.getArgSVal(idx);
 
     if (SymbolRef Sym = V.getAsLocSymbol()) {
       bool ShouldRemoveBinding = Summ.getArg(idx).getKind() == StopTrackingHard;
       if (const RefVal *T = getRefBinding(state, Sym))
         if (shouldEscapeOSArgumentOnCall(CallOrMsg, idx, T))
           ShouldRemoveBinding = true;
 
       if (ShouldRemoveBinding)
         state = removeRefBinding(state, Sym);
     }
   }
 
   // Evaluate the effect on the message receiver.
   if (const auto *MsgInvocation = dyn_cast<ObjCMethodCall>(&CallOrMsg)) {
     if (SymbolRef Sym = MsgInvocation->getReceiverSVal().getAsLocSymbol()) {
       if (Summ.getReceiverEffect().getKind() == StopTrackingHard) {
         state = removeRefBinding(state, Sym);
       }
     }
   }
 
   // Consult the summary for the return value.
   RetEffect RE = Summ.getRetEffect();
 
   if (SymbolRef Sym = CallOrMsg.getReturnValue().getAsSymbol()) {
     if (RE.getKind() == RetEffect::NoRetHard)
       state = removeRefBinding(state, Sym);
   }
 
   C.addTransition(state);
 }
 
 static bool isSmartPtrField(const MemRegion *MR) {
   const auto *TR = dyn_cast<TypedValueRegion>(
     cast<SubRegion>(MR)->getSuperRegion());
   return TR && RetainSummaryManager::isKnownSmartPointer(TR->getValueType());
 }
 
 
 /// A value escapes in these possible cases:
 ///
 /// - binding to something that is not a memory region.
 /// - binding to a memregion that does not have stack storage
 /// - binding to a variable that has a destructor attached using CleanupAttr
 ///
 /// We do not currently model what happens when a symbol is
 /// assigned to a struct field, unless it is a known smart pointer
 /// implementation, about which we know that it is inlined.
 /// FIXME: This could definitely be improved upon.
 static bool shouldEscapeRegion(const MemRegion *R) {
   if (isSmartPtrField(R))
     return false;
 
   const auto *VR = dyn_cast<VarRegion>(R);
 
   if (!R->hasStackStorage() || !VR)
     return true;
 
   const VarDecl *VD = VR->getDecl();
   if (!VD->hasAttr<CleanupAttr>())
     return false; // CleanupAttr attaches destructors, which cause escaping.
   return true;
 }
 
 static SmallVector<ProgramStateRef, 2>
 updateOutParameters(ProgramStateRef State, const RetainSummary &Summ,
                     const CallEvent &CE) {
 
   SVal L = CE.getReturnValue();
 
   // Splitting is required to support out parameters,
   // as out parameters might be created only on the "success" branch.
   // We want to avoid eagerly splitting unless out parameters are actually
   // needed.
   bool SplitNecessary = false;
   for (auto &P : Summ.getArgEffects())
     if (P.second.getKind() == RetainedOutParameterOnNonZero ||
         P.second.getKind() == RetainedOutParameterOnZero)
       SplitNecessary = true;
 
   ProgramStateRef AssumeNonZeroReturn = State;
   ProgramStateRef AssumeZeroReturn = State;
 
   if (SplitNecessary) {
     if (auto DL = L.getAs<DefinedOrUnknownSVal>()) {
       AssumeNonZeroReturn = AssumeNonZeroReturn->assume(*DL, true);
       AssumeZeroReturn = AssumeZeroReturn->assume(*DL, false);
     }
   }
 
   for (unsigned idx = 0, e = CE.getNumArgs(); idx != e; ++idx) {
     SVal ArgVal = CE.getArgSVal(idx);
     ArgEffect AE = Summ.getArg(idx);
 
     auto *ArgRegion = dyn_cast_or_null<TypedValueRegion>(ArgVal.getAsRegion());
     if (!ArgRegion)
       continue;
 
     QualType PointeeTy = ArgRegion->getValueType();
     SVal PointeeVal = State->getSVal(ArgRegion);
     SymbolRef Pointee = PointeeVal.getAsLocSymbol();
     if (!Pointee)
       continue;
 
     if (shouldEscapeRegion(ArgRegion))
       continue;
 
     auto makeNotOwnedParameter = [&](ProgramStateRef St) {
       return setRefBinding(St, Pointee,
                            RefVal::makeNotOwned(AE.getObjKind(), PointeeTy));
     };
     auto makeOwnedParameter = [&](ProgramStateRef St) {
       return setRefBinding(St, Pointee,
                            RefVal::makeOwned(ObjKind::OS, PointeeTy));
     };
 
     switch (AE.getKind()) {
     case UnretainedOutParameter:
       AssumeNonZeroReturn = makeNotOwnedParameter(AssumeNonZeroReturn);
       AssumeZeroReturn = makeNotOwnedParameter(AssumeZeroReturn);
       break;
     case RetainedOutParameter:
       AssumeNonZeroReturn = makeOwnedParameter(AssumeNonZeroReturn);
       AssumeZeroReturn = makeOwnedParameter(AssumeZeroReturn);
       break;
     case RetainedOutParameterOnNonZero:
       AssumeNonZeroReturn = makeOwnedParameter(AssumeNonZeroReturn);
       break;
     case RetainedOutParameterOnZero:
       AssumeZeroReturn = makeOwnedParameter(AssumeZeroReturn);
       break;
     default:
       break;
     }
   }
 
   if (SplitNecessary) {
     return {AssumeNonZeroReturn, AssumeZeroReturn};
   } else {
     assert(AssumeZeroReturn == AssumeNonZeroReturn);
     return {AssumeZeroReturn};
   }
 }
 
 void RetainCountChecker::checkSummary(const RetainSummary &Summ,
                                       const CallEvent &CallOrMsg,
                                       CheckerContext &C) const {
   ProgramStateRef state = C.getState();
 
   // Evaluate the effect of the arguments.
   RefVal::Kind hasErr = (RefVal::Kind) 0;
   SourceRange ErrorRange;
   SymbolRef ErrorSym = nullptr;
 
   // Helper tag for providing diagnostics: indicate whether dealloc was sent
   // at this location.
   bool DeallocSent = false;
 
   for (unsigned idx = 0, e = CallOrMsg.getNumArgs(); idx != e; ++idx) {
     SVal V = CallOrMsg.getArgSVal(idx);
 
     ArgEffect Effect = Summ.getArg(idx);
     if (SymbolRef Sym = V.getAsLocSymbol()) {
       if (const RefVal *T = getRefBinding(state, Sym)) {
 
         if (shouldEscapeOSArgumentOnCall(CallOrMsg, idx, T))
           Effect = ArgEffect(StopTrackingHard, ObjKind::OS);
 
         state = updateSymbol(state, Sym, *T, Effect, hasErr, C);
         if (hasErr) {
           ErrorRange = CallOrMsg.getArgSourceRange(idx);
           ErrorSym = Sym;
           break;
         } else if (Effect.getKind() == Dealloc) {
           DeallocSent = true;
         }
       }
     }
   }
 
   // Evaluate the effect on the message receiver / `this` argument.
   bool ReceiverIsTracked = false;
   if (!hasErr) {
     if (const auto *MsgInvocation = dyn_cast<ObjCMethodCall>(&CallOrMsg)) {
       if (SymbolRef Sym = MsgInvocation->getReceiverSVal().getAsLocSymbol()) {
         if (const RefVal *T = getRefBinding(state, Sym)) {
           ReceiverIsTracked = true;
           state = updateSymbol(state, Sym, *T,
                                Summ.getReceiverEffect(), hasErr, C);
           if (hasErr) {
             ErrorRange = MsgInvocation->getOriginExpr()->getReceiverRange();
             ErrorSym = Sym;
           } else if (Summ.getReceiverEffect().getKind() == Dealloc) {
             DeallocSent = true;
           }
         }
       }
     } else if (const auto *MCall = dyn_cast<CXXMemberCall>(&CallOrMsg)) {
       if (SymbolRef Sym = MCall->getCXXThisVal().getAsLocSymbol()) {
         if (const RefVal *T = getRefBinding(state, Sym)) {
           state = updateSymbol(state, Sym, *T, Summ.getThisEffect(),
                                hasErr, C);
           if (hasErr) {
             ErrorRange = MCall->getOriginExpr()->getSourceRange();
             ErrorSym = Sym;
           }
         }
       }
     }
   }
 
   // Process any errors.
   if (hasErr) {
     processNonLeakError(state, ErrorRange, hasErr, ErrorSym, C);
     return;
   }
 
   // Consult the summary for the return value.
   RetEffect RE = Summ.getRetEffect();
 
   if (RE.getKind() == RetEffect::OwnedWhenTrackedReceiver) {
     if (ReceiverIsTracked)
       RE = getSummaryManager(C).getObjAllocRetEffect();
     else
       RE = RetEffect::MakeNoRet();
   }
 
   if (SymbolRef Sym = CallOrMsg.getReturnValue().getAsSymbol()) {
     QualType ResultTy = CallOrMsg.getResultType();
     if (RE.notOwned()) {
       const Expr *Ex = CallOrMsg.getOriginExpr();
       assert(Ex);
       ResultTy = GetReturnType(Ex, C.getASTContext());
     }
     if (Optional<RefVal> updatedRefVal = refValFromRetEffect(RE, ResultTy))
       state = setRefBinding(state, Sym, *updatedRefVal);
   }
 
   SmallVector<ProgramStateRef, 2> Out =
       updateOutParameters(state, Summ, CallOrMsg);
 
   for (ProgramStateRef St : Out) {
     if (DeallocSent) {
       C.addTransition(St, C.getPredecessor(), &DeallocSentTag);
     } else {
       C.addTransition(St);
     }
   }
 }
 
 ProgramStateRef RetainCountChecker::updateSymbol(ProgramStateRef state,
                                                  SymbolRef sym, RefVal V,
                                                  ArgEffect AE,
                                                  RefVal::Kind &hasErr,
                                                  CheckerContext &C) const {
   bool IgnoreRetainMsg = (bool)C.getASTContext().getLangOpts().ObjCAutoRefCount;
   if (AE.getObjKind() == ObjKind::ObjC && IgnoreRetainMsg) {
     switch (AE.getKind()) {
     default:
       break;
     case IncRef:
       AE = AE.withKind(DoNothing);
       break;
     case DecRef:
       AE = AE.withKind(DoNothing);
       break;
     case DecRefAndStopTrackingHard:
       AE = AE.withKind(StopTracking);
       break;
     }
   }
 
   // Handle all use-after-releases.
   if (V.getKind() == RefVal::Released) {
     V = V ^ RefVal::ErrorUseAfterRelease;
     hasErr = V.getKind();
     return setRefBinding(state, sym, V);
   }
 
   switch (AE.getKind()) {
     case UnretainedOutParameter:
     case RetainedOutParameter:
     case RetainedOutParameterOnZero:
     case RetainedOutParameterOnNonZero:
       llvm_unreachable("Applies to pointer-to-pointer parameters, which should "
                        "not have ref state.");
 
     case Dealloc: // NB. we only need to add a note in a non-error case.
       switch (V.getKind()) {
         default:
           llvm_unreachable("Invalid RefVal state for an explicit dealloc.");
         case RefVal::Owned:
           // The object immediately transitions to the released state.
           V = V ^ RefVal::Released;
           V.clearCounts();
           return setRefBinding(state, sym, V);
         case RefVal::NotOwned:
           V = V ^ RefVal::ErrorDeallocNotOwned;
           hasErr = V.getKind();
           break;
       }
       break;
 
     case MayEscape:
       if (V.getKind() == RefVal::Owned) {
         V = V ^ RefVal::NotOwned;
         break;
       }
 
       LLVM_FALLTHROUGH;
 
     case DoNothing:
       return state;
 
     case Autorelease:
       // Update the autorelease counts.
       V = V.autorelease();
       break;
 
     case StopTracking:
     case StopTrackingHard:
       return removeRefBinding(state, sym);
 
     case IncRef:
       switch (V.getKind()) {
         default:
           llvm_unreachable("Invalid RefVal state for a retain.");
         case RefVal::Owned:
         case RefVal::NotOwned:
           V = V + 1;
           break;
       }
       break;
 
     case DecRef:
     case DecRefBridgedTransferred:
     case DecRefAndStopTrackingHard:
       switch (V.getKind()) {
         default:
           // case 'RefVal::Released' handled above.
           llvm_unreachable("Invalid RefVal state for a release.");
 
         case RefVal::Owned:
           assert(V.getCount() > 0);
           if (V.getCount() == 1) {
             if (AE.getKind() == DecRefBridgedTransferred ||
                 V.getIvarAccessHistory() ==
                   RefVal::IvarAccessHistory::AccessedDirectly)
               V = V ^ RefVal::NotOwned;
             else
               V = V ^ RefVal::Released;
           } else if (AE.getKind() == DecRefAndStopTrackingHard) {
             return removeRefBinding(state, sym);
           }
 
           V = V - 1;
           break;
 
         case RefVal::NotOwned:
           if (V.getCount() > 0) {
             if (AE.getKind() == DecRefAndStopTrackingHard)
               return removeRefBinding(state, sym);
             V = V - 1;
           } else if (V.getIvarAccessHistory() ==
                        RefVal::IvarAccessHistory::AccessedDirectly) {
             // Assume that the instance variable was holding on the object at
             // +1, and we just didn't know.
             if (AE.getKind() == DecRefAndStopTrackingHard)
               return removeRefBinding(state, sym);
             V = V.releaseViaIvar() ^ RefVal::Released;
           } else {
             V = V ^ RefVal::ErrorReleaseNotOwned;
             hasErr = V.getKind();
           }
           break;
       }
       break;
   }
   return setRefBinding(state, sym, V);
 }
 
 const RefCountBug &
 RetainCountChecker::errorKindToBugKind(RefVal::Kind ErrorKind,
                                        SymbolRef Sym) const {
   switch (ErrorKind) {
     case RefVal::ErrorUseAfterRelease:
       return useAfterRelease;
     case RefVal::ErrorReleaseNotOwned:
       return releaseNotOwned;
     case RefVal::ErrorDeallocNotOwned:
       if (Sym->getType()->getPointeeCXXRecordDecl())
         return freeNotOwned;
       return deallocNotOwned;
     default:
       llvm_unreachable("Unhandled error.");
   }
 }
 
 void RetainCountChecker::processNonLeakError(ProgramStateRef St,
                                              SourceRange ErrorRange,
                                              RefVal::Kind ErrorKind,
                                              SymbolRef Sym,
                                              CheckerContext &C) const {
   // HACK: Ignore retain-count issues on values accessed through ivars,
   // because of cases like this:
   //   [_contentView retain];
   //   [_contentView removeFromSuperview];
   //   [self addSubview:_contentView]; // invalidates 'self'
   //   [_contentView release];
   if (const RefVal *RV = getRefBinding(St, Sym))
     if (RV->getIvarAccessHistory() != RefVal::IvarAccessHistory::None)
       return;
 
   ExplodedNode *N = C.generateErrorNode(St);
   if (!N)
     return;
 
   auto report = llvm::make_unique<RefCountReport>(
       errorKindToBugKind(ErrorKind, Sym),
       C.getASTContext().getLangOpts(), N, Sym);
   report->addRange(ErrorRange);
   C.emitReport(std::move(report));
 }
 
 //===----------------------------------------------------------------------===//
 // Handle the return values of retain-count-related functions.
 //===----------------------------------------------------------------------===//
 
 bool RetainCountChecker::evalCall(const CallExpr *CE, CheckerContext &C) const {
   ProgramStateRef state = C.getState();
   const FunctionDecl *FD = C.getCalleeDecl(CE);
   if (!FD)
     return false;
 
   RetainSummaryManager &SmrMgr = getSummaryManager(C);
   QualType ResultTy = CE->getCallReturnType(C.getASTContext());
 
   // See if the function has 'rc_ownership_trusted_implementation'
   // annotate attribute. If it does, we will not inline it.
   bool hasTrustedImplementationAnnotation = false;
 
   const LocationContext *LCtx = C.getLocationContext();
 
   using BehaviorSummary = RetainSummaryManager::BehaviorSummary;
   Optional<BehaviorSummary> BSmr =
       SmrMgr.canEval(CE, FD, hasTrustedImplementationAnnotation);
 
   // See if it's one of the specific functions we know how to eval.
   if (!BSmr)
     return false;
 
   // Bind the return value.
   if (BSmr == BehaviorSummary::Identity ||
       BSmr == BehaviorSummary::IdentityOrZero ||
       BSmr == BehaviorSummary::IdentityThis) {
 
     const Expr *BindReturnTo =
         (BSmr == BehaviorSummary::IdentityThis)
             ? cast<CXXMemberCallExpr>(CE)->getImplicitObjectArgument()
             : CE->getArg(0);
     SVal RetVal = state->getSVal(BindReturnTo, LCtx);
 
     // If the receiver is unknown or the function has
     // 'rc_ownership_trusted_implementation' annotate attribute, conjure a
     // return value.
     // FIXME: this branch is very strange.
     if (RetVal.isUnknown() ||
         (hasTrustedImplementationAnnotation && !ResultTy.isNull())) {
       SValBuilder &SVB = C.getSValBuilder();
       RetVal =
           SVB.conjureSymbolVal(nullptr, CE, LCtx, ResultTy, C.blockCount());
     }
 
     // Bind the value.
     state = state->BindExpr(CE, LCtx, RetVal, /*Invalidate=*/false);
 
     if (BSmr == BehaviorSummary::IdentityOrZero) {
       // Add a branch where the output is zero.
       ProgramStateRef NullOutputState = C.getState();
 
       // Assume that output is zero on the other branch.
       NullOutputState = NullOutputState->BindExpr(
           CE, LCtx, C.getSValBuilder().makeNull(), /*Invalidate=*/false);
       C.addTransition(NullOutputState, &CastFailTag);
 
       // And on the original branch assume that both input and
       // output are non-zero.
       if (auto L = RetVal.getAs<DefinedOrUnknownSVal>())
         state = state->assume(*L, /*Assumption=*/true);
 
     }
   }
 
   C.addTransition(state);
   return true;
 }
 
 ExplodedNode * RetainCountChecker::processReturn(const ReturnStmt *S,
                                                  CheckerContext &C) const {
   ExplodedNode *Pred = C.getPredecessor();
 
   // Only adjust the reference count if this is the top-level call frame,
   // and not the result of inlining.  In the future, we should do
   // better checking even for inlined calls, and see if they match
   // with their expected semantics (e.g., the method should return a retained
   // object, etc.).
   if (!C.inTopFrame())
     return Pred;
 
   if (!S)
     return Pred;
 
   const Expr *RetE = S->getRetValue();
   if (!RetE)
     return Pred;
 
   ProgramStateRef state = C.getState();
   SymbolRef Sym =
     state->getSValAsScalarOrLoc(RetE, C.getLocationContext()).getAsLocSymbol();
   if (!Sym)
     return Pred;
 
   // Get the reference count binding (if any).
   const RefVal *T = getRefBinding(state, Sym);
   if (!T)
     return Pred;
 
   // Change the reference count.
   RefVal X = *T;
 
   switch (X.getKind()) {
     case RefVal::Owned: {
       unsigned cnt = X.getCount();
       assert(cnt > 0);
       X.setCount(cnt - 1);
       X = X ^ RefVal::ReturnedOwned;
       break;
     }
 
     case RefVal::NotOwned: {
       unsigned cnt = X.getCount();
       if (cnt) {
         X.setCount(cnt - 1);
         X = X ^ RefVal::ReturnedOwned;
       } else {
         X = X ^ RefVal::ReturnedNotOwned;
       }
       break;
     }
 
     default:
       return Pred;
   }
 
   // Update the binding.
   state = setRefBinding(state, Sym, X);
   Pred = C.addTransition(state);
 
   // At this point we have updated the state properly.
   // Everything after this is merely checking to see if the return value has
   // been over- or under-retained.
 
   // Did we cache out?
   if (!Pred)
     return nullptr;
 
   // Update the autorelease counts.
   static CheckerProgramPointTag AutoreleaseTag(this, "Autorelease");
   state = handleAutoreleaseCounts(state, Pred, &AutoreleaseTag, C, Sym, X, S);
 
   // Have we generated a sink node?
   if (!state)
     return nullptr;
 
   // Get the updated binding.
   T = getRefBinding(state, Sym);
   assert(T);
   X = *T;
 
   // Consult the summary of the enclosing method.
   RetainSummaryManager &Summaries = getSummaryManager(C);
   const Decl *CD = &Pred->getCodeDecl();
   RetEffect RE = RetEffect::MakeNoRet();
 
   // FIXME: What is the convention for blocks? Is there one?
   if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(CD)) {
     const RetainSummary *Summ = Summaries.getSummary(AnyCall(MD));
     RE = Summ->getRetEffect();
   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(CD)) {
     if (!isa<CXXMethodDecl>(FD)) {
       const RetainSummary *Summ = Summaries.getSummary(AnyCall(FD));
       RE = Summ->getRetEffect();
     }
   }
 
   return checkReturnWithRetEffect(S, C, Pred, RE, X, Sym, state);
 }
 
 ExplodedNode * RetainCountChecker::checkReturnWithRetEffect(const ReturnStmt *S,
                                                   CheckerContext &C,
                                                   ExplodedNode *Pred,
                                                   RetEffect RE, RefVal X,
                                                   SymbolRef Sym,
                                                   ProgramStateRef state) const {
   // HACK: Ignore retain-count issues on values accessed through ivars,
   // because of cases like this:
   //   [_contentView retain];
   //   [_contentView removeFromSuperview];
   //   [self addSubview:_contentView]; // invalidates 'self'
   //   [_contentView release];
   if (X.getIvarAccessHistory() != RefVal::IvarAccessHistory::None)
     return Pred;
 
   // Any leaks or other errors?
   if (X.isReturnedOwned() && X.getCount() == 0) {
     if (RE.getKind() != RetEffect::NoRet) {
       if (!RE.isOwned()) {
 
         // The returning type is a CF, we expect the enclosing method should
         // return ownership.
         X = X ^ RefVal::ErrorLeakReturned;
 
         // Generate an error node.
         state = setRefBinding(state, Sym, X);
 
         static CheckerProgramPointTag ReturnOwnLeakTag(this, "ReturnsOwnLeak");
         ExplodedNode *N = C.addTransition(state, Pred, &ReturnOwnLeakTag);
         if (N) {
           const LangOptions &LOpts = C.getASTContext().getLangOpts();
           auto R =
               llvm::make_unique<RefLeakReport>(leakAtReturn, LOpts, N, Sym, C);
           C.emitReport(std::move(R));
         }
         return N;
       }
     }
   } else if (X.isReturnedNotOwned()) {
     if (RE.isOwned()) {
       if (X.getIvarAccessHistory() ==
             RefVal::IvarAccessHistory::AccessedDirectly) {
         // Assume the method was trying to transfer a +1 reference from a
         // strong ivar to the caller.
         state = setRefBinding(state, Sym,
                               X.releaseViaIvar() ^ RefVal::ReturnedOwned);
       } else {
         // Trying to return a not owned object to a caller expecting an
         // owned object.
         state = setRefBinding(state, Sym, X ^ RefVal::ErrorReturnedNotOwned);
 
         static CheckerProgramPointTag
             ReturnNotOwnedTag(this, "ReturnNotOwnedForOwned");
 
         ExplodedNode *N = C.addTransition(state, Pred, &ReturnNotOwnedTag);
         if (N) {
           auto R = llvm::make_unique<RefCountReport>(
               returnNotOwnedForOwned, C.getASTContext().getLangOpts(), N, Sym);
           C.emitReport(std::move(R));
         }
         return N;
       }
     }
   }
   return Pred;
 }
 
 //===----------------------------------------------------------------------===//
 // Check various ways a symbol can be invalidated.
 //===----------------------------------------------------------------------===//
 
 void RetainCountChecker::checkBind(SVal loc, SVal val, const Stmt *S,
                                    CheckerContext &C) const {
   ProgramStateRef state = C.getState();
   const MemRegion *MR = loc.getAsRegion();
 
   // Find all symbols referenced by 'val' that we are tracking
   // and stop tracking them.
   if (MR && shouldEscapeRegion(MR)) {
     state = state->scanReachableSymbols<StopTrackingCallback>(val).getState();
     C.addTransition(state);
   }
 }
 
 ProgramStateRef RetainCountChecker::evalAssume(ProgramStateRef state,
                                                SVal Cond,
                                                bool Assumption) const {
   // FIXME: We may add to the interface of evalAssume the list of symbols
   //  whose assumptions have changed.  For now we just iterate through the
   //  bindings and check if any of the tracked symbols are NULL.  This isn't
   //  too bad since the number of symbols we will track in practice are
   //  probably small and evalAssume is only called at branches and a few
   //  other places.
   RefBindingsTy B = state->get<RefBindings>();
 
   if (B.isEmpty())
     return state;
 
   bool changed = false;
   RefBindingsTy::Factory &RefBFactory = state->get_context<RefBindings>();
   ConstraintManager &CMgr = state->getConstraintManager();
 
   for (auto &I : B) {
     // Check if the symbol is null stop tracking the symbol.
     ConditionTruthVal AllocFailed = CMgr.isNull(state, I.first);
     if (AllocFailed.isConstrainedTrue()) {
       changed = true;
       B = RefBFactory.remove(B, I.first);
     }
   }
 
   if (changed)
     state = state->set<RefBindings>(B);
 
   return state;
 }
 
 ProgramStateRef RetainCountChecker::checkRegionChanges(
     ProgramStateRef state, const InvalidatedSymbols *invalidated,
     ArrayRef<const MemRegion *> ExplicitRegions,
     ArrayRef<const MemRegion *> Regions, const LocationContext *LCtx,
     const CallEvent *Call) const {
   if (!invalidated)
     return state;
 
   llvm::SmallPtrSet<SymbolRef, 8> WhitelistedSymbols;
 
   for (const MemRegion *I : ExplicitRegions)
     if (const SymbolicRegion *SR = I->StripCasts()->getAs<SymbolicRegion>())
       WhitelistedSymbols.insert(SR->getSymbol());
 
   for (SymbolRef sym : *invalidated) {
     if (WhitelistedSymbols.count(sym))
       continue;
     // Remove any existing reference-count binding.
     state = removeRefBinding(state, sym);
   }
   return state;
 }
 
 ProgramStateRef
 RetainCountChecker::handleAutoreleaseCounts(ProgramStateRef state,
                                             ExplodedNode *Pred,
                                             const ProgramPointTag *Tag,
                                             CheckerContext &Ctx,
                                             SymbolRef Sym,
                                             RefVal V,
                                             const ReturnStmt *S) const {
   unsigned ACnt = V.getAutoreleaseCount();
 
   // No autorelease counts?  Nothing to be done.
   if (!ACnt)
     return state;
 
   unsigned Cnt = V.getCount();
 
   // FIXME: Handle sending 'autorelease' to already released object.
 
   if (V.getKind() == RefVal::ReturnedOwned)
     ++Cnt;
 
   // If we would over-release here, but we know the value came from an ivar,
   // assume it was a strong ivar that's just been relinquished.
   if (ACnt > Cnt &&
       V.getIvarAccessHistory() == RefVal::IvarAccessHistory::AccessedDirectly) {
     V = V.releaseViaIvar();
     --ACnt;
   }
 
   if (ACnt <= Cnt) {
     if (ACnt == Cnt) {
       V.clearCounts();
       if (V.getKind() == RefVal::ReturnedOwned) {
         V = V ^ RefVal::ReturnedNotOwned;
       } else {
         V = V ^ RefVal::NotOwned;
       }
     } else {
       V.setCount(V.getCount() - ACnt);
       V.setAutoreleaseCount(0);
     }
     return setRefBinding(state, Sym, V);
   }
 
   // HACK: Ignore retain-count issues on values accessed through ivars,
   // because of cases like this:
   //   [_contentView retain];
   //   [_contentView removeFromSuperview];
   //   [self addSubview:_contentView]; // invalidates 'self'
   //   [_contentView release];
   if (V.getIvarAccessHistory() != RefVal::IvarAccessHistory::None)
     return state;
 
   // Woah!  More autorelease counts then retain counts left.
   // Emit hard error.
   V = V ^ RefVal::ErrorOverAutorelease;
   state = setRefBinding(state, Sym, V);
 
   ExplodedNode *N = Ctx.generateSink(state, Pred, Tag);
   if (N) {
     SmallString<128> sbuf;
     llvm::raw_svector_ostream os(sbuf);
     os << "Object was autoreleased ";
     if (V.getAutoreleaseCount() > 1)
       os << V.getAutoreleaseCount() << " times but the object ";
     else
       os << "but ";
     os << "has a +" << V.getCount() << " retain count";
 
     const LangOptions &LOpts = Ctx.getASTContext().getLangOpts();
     auto R = llvm::make_unique<RefCountReport>(overAutorelease, LOpts, N, Sym,
                                                os.str());
     Ctx.emitReport(std::move(R));
   }
 
   return nullptr;
 }
 
 ProgramStateRef
 RetainCountChecker::handleSymbolDeath(ProgramStateRef state,
                                       SymbolRef sid, RefVal V,
                                     SmallVectorImpl<SymbolRef> &Leaked) const {
   bool hasLeak;
 
   // HACK: Ignore retain-count issues on values accessed through ivars,
   // because of cases like this:
   //   [_contentView retain];
   //   [_contentView removeFromSuperview];
   //   [self addSubview:_contentView]; // invalidates 'self'
   //   [_contentView release];
   if (V.getIvarAccessHistory() != RefVal::IvarAccessHistory::None)
     hasLeak = false;
   else if (V.isOwned())
     hasLeak = true;
   else if (V.isNotOwned() || V.isReturnedOwned())
     hasLeak = (V.getCount() > 0);
   else
     hasLeak = false;
 
   if (!hasLeak)
     return removeRefBinding(state, sid);
 
   Leaked.push_back(sid);
   return setRefBinding(state, sid, V ^ RefVal::ErrorLeak);
 }
 
 ExplodedNode *
 RetainCountChecker::processLeaks(ProgramStateRef state,
                                  SmallVectorImpl<SymbolRef> &Leaked,
                                  CheckerContext &Ctx,
                                  ExplodedNode *Pred) const {
   // Generate an intermediate node representing the leak point.
   ExplodedNode *N = Ctx.addTransition(state, Pred);
   const LangOptions &LOpts = Ctx.getASTContext().getLangOpts();
 
   if (N) {
     for (SymbolRef L : Leaked) {
       const RefCountBug &BT = Pred ? leakWithinFunction : leakAtReturn;
       Ctx.emitReport(llvm::make_unique<RefLeakReport>(BT, LOpts, N, L, Ctx));
     }
   }
 
   return N;
 }
 
-static bool isISLObjectRef(QualType Ty) {
-  return StringRef(Ty.getAsString()).startswith("isl_");
-}
-
 void RetainCountChecker::checkBeginFunction(CheckerContext &Ctx) const {
   if (!Ctx.inTopFrame())
     return;
 
   RetainSummaryManager &SmrMgr = getSummaryManager(Ctx);
   const LocationContext *LCtx = Ctx.getLocationContext();
   const FunctionDecl *FD = dyn_cast<FunctionDecl>(LCtx->getDecl());
 
   if (!FD || SmrMgr.isTrustedReferenceCountImplementation(FD))
     return;
 
   ProgramStateRef state = Ctx.getState();
   const RetainSummary *FunctionSummary = SmrMgr.getSummary(AnyCall(FD));
   ArgEffects CalleeSideArgEffects = FunctionSummary->getArgEffects();
 
   for (unsigned idx = 0, e = FD->getNumParams(); idx != e; ++idx) {
     const ParmVarDecl *Param = FD->getParamDecl(idx);
     SymbolRef Sym = state->getSVal(state->getRegion(Param, LCtx)).getAsSymbol();
 
     QualType Ty = Param->getType();
     const ArgEffect *AE = CalleeSideArgEffects.lookup(idx);
-    if (AE && AE->getKind() == DecRef && isISLObjectRef(Ty)) {
-      state = setRefBinding(
-          state, Sym, RefVal::makeOwned(ObjKind::Generalized, Ty));
-    } else if (isISLObjectRef(Ty)) {
-      state = setRefBinding(
-          state, Sym,
-          RefVal::makeNotOwned(ObjKind::Generalized, Ty));
+    if (AE) {
+      ObjKind K = AE->getObjKind();
+      if (K == ObjKind::Generalized || K == ObjKind::OS ||
+          (TrackNSCFStartParam && (K == ObjKind::ObjC || K == ObjKind::CF))) {
+        RefVal NewVal = AE->getKind() == DecRef ? RefVal::makeOwned(K, Ty)
+                                                : RefVal::makeNotOwned(K, Ty);
+        state = setRefBinding(state, Sym, NewVal);
+      }
     }
   }
 
   Ctx.addTransition(state);
 }
 
 void RetainCountChecker::checkEndFunction(const ReturnStmt *RS,
                                           CheckerContext &Ctx) const {
   ExplodedNode *Pred = processReturn(RS, Ctx);
 
   // Created state cached out.
   if (!Pred) {
     return;
   }
 
   ProgramStateRef state = Pred->getState();
   RefBindingsTy B = state->get<RefBindings>();
 
   // Don't process anything within synthesized bodies.
   const LocationContext *LCtx = Pred->getLocationContext();
   if (LCtx->getAnalysisDeclContext()->isBodyAutosynthesized()) {
     assert(!LCtx->inTopFrame());
     return;
   }
 
   for (auto &I : B) {
     state = handleAutoreleaseCounts(state, Pred, /*Tag=*/nullptr, Ctx,
                                     I.first, I.second);
     if (!state)
       return;
   }
 
   // If the current LocationContext has a parent, don't check for leaks.
   // We will do that later.
   // FIXME: we should instead check for imbalances of the retain/releases,
   // and suggest annotations.
   if (LCtx->getParent())
     return;
 
   B = state->get<RefBindings>();
   SmallVector<SymbolRef, 10> Leaked;
 
   for (auto &I : B)
     state = handleSymbolDeath(state, I.first, I.second, Leaked);
 
   processLeaks(state, Leaked, Ctx, Pred);
 }
 
 void RetainCountChecker::checkDeadSymbols(SymbolReaper &SymReaper,
                                           CheckerContext &C) const {
   ExplodedNode *Pred = C.getPredecessor();
 
   ProgramStateRef state = C.getState();
   SmallVector<SymbolRef, 10> Leaked;
 
   // Update counts from autorelease pools
   for (const auto &I: state->get<RefBindings>()) {
     SymbolRef Sym = I.first;
     if (SymReaper.isDead(Sym)) {
       static CheckerProgramPointTag Tag(this, "DeadSymbolAutorelease");
       const RefVal &V = I.second;
       state = handleAutoreleaseCounts(state, Pred, &Tag, C, Sym, V);
       if (!state)
         return;
 
       // Fetch the new reference count from the state, and use it to handle
       // this symbol.
       state = handleSymbolDeath(state, Sym, *getRefBinding(state, Sym), Leaked);
     }
   }
 
   if (Leaked.empty()) {
     C.addTransition(state);
     return;
   }
 
   Pred = processLeaks(state, Leaked, C, Pred);
 
   // Did we cache out?
   if (!Pred)
     return;
 
   // Now generate a new node that nukes the old bindings.
   // The only bindings left at this point are the leaked symbols.
   RefBindingsTy::Factory &F = state->get_context<RefBindings>();
   RefBindingsTy B = state->get<RefBindings>();
 
   for (SymbolRef L : Leaked)
     B = F.remove(B, L);
 
   state = state->set<RefBindings>(B);
   C.addTransition(state, Pred);
 }
 
 void RetainCountChecker::printState(raw_ostream &Out, ProgramStateRef State,
                                     const char *NL, const char *Sep) const {
 
   RefBindingsTy B = State->get<RefBindings>();
 
   if (B.isEmpty())
     return;
 
   Out << Sep << NL;
 
   for (auto &I : B) {
     Out << I.first << " : ";
     I.second.print(Out);
     Out << NL;
   }
 }
 
 //===----------------------------------------------------------------------===//
 // Checker registration.
 //===----------------------------------------------------------------------===//
 
 void ento::registerRetainCountBase(CheckerManager &Mgr) {
   Mgr.registerChecker<RetainCountChecker>();
 }
 
 bool ento::shouldRegisterRetainCountBase(const LangOptions &LO) {
   return true;
 }
 
+// FIXME: remove this, hack for backwards compatibility:
+// it should be possible to enable the NS/CF retain count checker as
+// osx.cocoa.RetainCount, and it should be possible to disable
+// osx.OSObjectRetainCount using osx.cocoa.RetainCount:CheckOSObject=false.
+static bool getOption(AnalyzerOptions &Options,
+                      StringRef Postfix,
+                      StringRef Value) {
+  auto I = Options.Config.find(
+    (StringRef("osx.cocoa.RetainCount:") + Postfix).str());
+  if (I != Options.Config.end())
+    return I->getValue() == Value;
+  return false;
+}
+
 void ento::registerRetainCountChecker(CheckerManager &Mgr) {
   auto *Chk = Mgr.getChecker<RetainCountChecker>();
   Chk->TrackObjCAndCFObjects = true;
+  Chk->TrackNSCFStartParam = getOption(Mgr.getAnalyzerOptions(),
+                                       "TrackNSCFStartParam",
+                                       "true");
 }
 
 bool ento::shouldRegisterRetainCountChecker(const LangOptions &LO) {
   return true;
 }
 
-// FIXME: remove this, hack for backwards compatibility:
-// it should be possible to enable the NS/CF retain count checker as
-// osx.cocoa.RetainCount, and it should be possible to disable
-// osx.OSObjectRetainCount using osx.cocoa.RetainCount:CheckOSObject=false.
-static bool hasPrevCheckOSObjectOptionDisabled(AnalyzerOptions &Options) {
-  auto I = Options.Config.find("osx.cocoa.RetainCount:CheckOSObject");
-  if (I != Options.Config.end())
-    return I->getValue() == "false";
-  return false;
-}
-
 void ento::registerOSObjectRetainCountChecker(CheckerManager &Mgr) {
   auto *Chk = Mgr.getChecker<RetainCountChecker>();
-  if (!hasPrevCheckOSObjectOptionDisabled(Mgr.getAnalyzerOptions()))
+  if (!getOption(Mgr.getAnalyzerOptions(),
+                 "CheckOSObject",
+                 "false"))
     Chk->TrackOSObjects = true;
 }
 
 bool ento::shouldRegisterOSObjectRetainCountChecker(const LangOptions &LO) {
   return true;
 }
diff --git a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h
index 775cd21851d0..506ece1e5785 100644
--- a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h
+++ b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountChecker.h
@@ -1,395 +1,398 @@
 //==--- RetainCountChecker.h - Checks for leaks and other issues -*- C++ -*--//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the methods for RetainCountChecker, which implements
 //  a reference count checker for Core Foundation and Cocoa on (Mac OS X).
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_RETAINCOUNTCHECKER_H
 #define LLVM_CLANG_LIB_STATICANALYZER_CHECKERS_RETAINCOUNTCHECKER_H
 
 #include "clang/StaticAnalyzer/Checkers/BuiltinCheckerRegistration.h"
 #include "RetainCountDiagnostics.h"
 #include "clang/AST/Attr.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/ParentMap.h"
 #include "clang/Analysis/DomainSpecific/CocoaConventions.h"
 #include "clang/Analysis/RetainSummaryManager.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Analysis/SelectorExtras.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/BugType.h"
 #include "clang/StaticAnalyzer/Core/BugReporter/PathDiagnostic.h"
 #include "clang/StaticAnalyzer/Core/Checker.h"
 #include "clang/StaticAnalyzer/Core/CheckerManager.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/CheckerContext.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/ProgramStateTrait.h"
 #include "clang/StaticAnalyzer/Core/PathSensitive/SymbolManager.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/FoldingSet.h"
 #include "llvm/ADT/ImmutableList.h"
 #include "llvm/ADT/ImmutableMap.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/StringExtras.h"
 #include <cstdarg>
 #include <utility>
 
 namespace clang {
 namespace ento {
 namespace retaincountchecker {
 
 /// Metadata on reference.
 class RefVal {
 public:
   enum Kind {
     Owned = 0, // Owning reference.
     NotOwned,  // Reference is not owned by still valid (not freed).
     Released,  // Object has been released.
     ReturnedOwned, // Returned object passes ownership to caller.
     ReturnedNotOwned, // Return object does not pass ownership to caller.
     ERROR_START,
     ErrorDeallocNotOwned, // -dealloc called on non-owned object.
     ErrorUseAfterRelease, // Object used after released.
     ErrorReleaseNotOwned, // Release of an object that was not owned.
     ERROR_LEAK_START,
     ErrorLeak,  // A memory leak due to excessive reference counts.
     ErrorLeakReturned, // A memory leak due to the returning method not having
                        // the correct naming conventions.
     ErrorOverAutorelease,
     ErrorReturnedNotOwned
   };
 
   /// Tracks how an object referenced by an ivar has been used.
   ///
   /// This accounts for us not knowing if an arbitrary ivar is supposed to be
   /// stored at +0 or +1.
   enum class IvarAccessHistory {
     None,
     AccessedDirectly,
     ReleasedAfterDirectAccess
   };
 
 private:
   /// The number of outstanding retains.
   unsigned Cnt;
   /// The number of outstanding autoreleases.
   unsigned ACnt;
   /// The (static) type of the object at the time we started tracking it.
   QualType T;
 
   /// The current state of the object.
   ///
   /// See the RefVal::Kind enum for possible values.
   unsigned RawKind : 5;
 
   /// The kind of object being tracked (CF or ObjC or OSObject), if known.
   ///
   /// See the ObjKind enum for possible values.
   unsigned RawObjectKind : 3;
 
   /// True if the current state and/or retain count may turn out to not be the
   /// best possible approximation of the reference counting state.
   ///
   /// If true, the checker may decide to throw away ("override") this state
   /// in favor of something else when it sees the object being used in new ways.
   ///
   /// This setting should not be propagated to state derived from this state.
   /// Once we start deriving new states, it would be inconsistent to override
   /// them.
   unsigned RawIvarAccessHistory : 2;
 
   RefVal(Kind k, ObjKind o, unsigned cnt, unsigned acnt, QualType t,
          IvarAccessHistory IvarAccess)
     : Cnt(cnt), ACnt(acnt), T(t), RawKind(static_cast<unsigned>(k)),
       RawObjectKind(static_cast<unsigned>(o)),
       RawIvarAccessHistory(static_cast<unsigned>(IvarAccess)) {
     assert(getKind() == k && "not enough bits for the kind");
     assert(getObjKind() == o && "not enough bits for the object kind");
     assert(getIvarAccessHistory() == IvarAccess && "not enough bits");
   }
 
 public:
   Kind getKind() const { return static_cast<Kind>(RawKind); }
 
   ObjKind getObjKind() const {
     return static_cast<ObjKind>(RawObjectKind);
   }
 
   unsigned getCount() const { return Cnt; }
   unsigned getAutoreleaseCount() const { return ACnt; }
   unsigned getCombinedCounts() const { return Cnt + ACnt; }
   void clearCounts() {
     Cnt = 0;
     ACnt = 0;
   }
   void setCount(unsigned i) {
     Cnt = i;
   }
   void setAutoreleaseCount(unsigned i) {
     ACnt = i;
   }
 
   QualType getType() const { return T; }
 
   /// Returns what the analyzer knows about direct accesses to a particular
   /// instance variable.
   ///
   /// If the object with this refcount wasn't originally from an Objective-C
   /// ivar region, this should always return IvarAccessHistory::None.
   IvarAccessHistory getIvarAccessHistory() const {
     return static_cast<IvarAccessHistory>(RawIvarAccessHistory);
   }
 
   bool isOwned() const {
     return getKind() == Owned;
   }
 
   bool isNotOwned() const {
     return getKind() == NotOwned;
   }
 
   bool isReturnedOwned() const {
     return getKind() == ReturnedOwned;
   }
 
   bool isReturnedNotOwned() const {
     return getKind() == ReturnedNotOwned;
   }
 
   /// Create a state for an object whose lifetime is the responsibility of the
   /// current function, at least partially.
   ///
   /// Most commonly, this is an owned object with a retain count of +1.
   static RefVal makeOwned(ObjKind o, QualType t) {
     return RefVal(Owned, o, /*Count=*/1, 0, t, IvarAccessHistory::None);
   }
 
   /// Create a state for an object whose lifetime is not the responsibility of
   /// the current function.
   ///
   /// Most commonly, this is an unowned object with a retain count of +0.
   static RefVal makeNotOwned(ObjKind o, QualType t) {
     return RefVal(NotOwned, o, /*Count=*/0, 0, t, IvarAccessHistory::None);
   }
 
   RefVal operator-(size_t i) const {
     return RefVal(getKind(), getObjKind(), getCount() - i,
                   getAutoreleaseCount(), getType(), getIvarAccessHistory());
   }
 
   RefVal operator+(size_t i) const {
     return RefVal(getKind(), getObjKind(), getCount() + i,
                   getAutoreleaseCount(), getType(), getIvarAccessHistory());
   }
 
   RefVal operator^(Kind k) const {
     return RefVal(k, getObjKind(), getCount(), getAutoreleaseCount(),
                   getType(), getIvarAccessHistory());
   }
 
   RefVal autorelease() const {
     return RefVal(getKind(), getObjKind(), getCount(), getAutoreleaseCount()+1,
                   getType(), getIvarAccessHistory());
   }
 
   RefVal withIvarAccess() const {
     assert(getIvarAccessHistory() == IvarAccessHistory::None);
     return RefVal(getKind(), getObjKind(), getCount(), getAutoreleaseCount(),
                   getType(), IvarAccessHistory::AccessedDirectly);
   }
 
   RefVal releaseViaIvar() const {
     assert(getIvarAccessHistory() == IvarAccessHistory::AccessedDirectly);
     return RefVal(getKind(), getObjKind(), getCount(), getAutoreleaseCount(),
                   getType(), IvarAccessHistory::ReleasedAfterDirectAccess);
   }
 
   // Comparison, profiling, and pretty-printing.
   bool hasSameState(const RefVal &X) const {
     return getKind() == X.getKind() && Cnt == X.Cnt && ACnt == X.ACnt &&
            getIvarAccessHistory() == X.getIvarAccessHistory();
   }
 
   bool operator==(const RefVal& X) const {
     return T == X.T && hasSameState(X) && getObjKind() == X.getObjKind();
   }
 
   void Profile(llvm::FoldingSetNodeID& ID) const {
     ID.Add(T);
     ID.AddInteger(RawKind);
     ID.AddInteger(Cnt);
     ID.AddInteger(ACnt);
     ID.AddInteger(RawObjectKind);
     ID.AddInteger(RawIvarAccessHistory);
   }
 
   void print(raw_ostream &Out) const;
 };
 
 class RetainCountChecker
   : public Checker< check::Bind,
                     check::DeadSymbols,
                     check::BeginFunction,
                     check::EndFunction,
                     check::PostStmt<BlockExpr>,
                     check::PostStmt<CastExpr>,
                     check::PostStmt<ObjCArrayLiteral>,
                     check::PostStmt<ObjCDictionaryLiteral>,
                     check::PostStmt<ObjCBoxedExpr>,
                     check::PostStmt<ObjCIvarRefExpr>,
                     check::PostCall,
                     check::RegionChanges,
                     eval::Assume,
                     eval::Call > {
 
   RefCountBug useAfterRelease{this, RefCountBug::UseAfterRelease};
   RefCountBug releaseNotOwned{this, RefCountBug::ReleaseNotOwned};
   RefCountBug deallocNotOwned{this, RefCountBug::DeallocNotOwned};
   RefCountBug freeNotOwned{this, RefCountBug::FreeNotOwned};
   RefCountBug overAutorelease{this, RefCountBug::OverAutorelease};
   RefCountBug returnNotOwnedForOwned{this, RefCountBug::ReturnNotOwnedForOwned};
   RefCountBug leakWithinFunction{this, RefCountBug::LeakWithinFunction};
   RefCountBug leakAtReturn{this, RefCountBug::LeakAtReturn};
 
   CheckerProgramPointTag DeallocSentTag{this, "DeallocSent"};
   CheckerProgramPointTag CastFailTag{this, "DynamicCastFail"};
 
   mutable std::unique_ptr<RetainSummaryManager> Summaries;
 public:
 
   /// Track Objective-C and CoreFoundation objects.
   bool TrackObjCAndCFObjects = false;
 
   /// Track sublcasses of OSObject.
   bool TrackOSObjects = false;
 
+  /// Track initial parameters (for the entry point) for NS/CF objects.
+  bool TrackNSCFStartParam = false;
+
   RetainCountChecker() {};
 
   RetainSummaryManager &getSummaryManager(ASTContext &Ctx) const {
     if (!Summaries)
       Summaries.reset(
           new RetainSummaryManager(Ctx, TrackObjCAndCFObjects, TrackOSObjects));
     return *Summaries;
   }
 
   RetainSummaryManager &getSummaryManager(CheckerContext &C) const {
     return getSummaryManager(C.getASTContext());
   }
 
   void printState(raw_ostream &Out, ProgramStateRef State,
                   const char *NL, const char *Sep) const override;
 
   void checkBind(SVal loc, SVal val, const Stmt *S, CheckerContext &C) const;
   void checkPostStmt(const BlockExpr *BE, CheckerContext &C) const;
   void checkPostStmt(const CastExpr *CE, CheckerContext &C) const;
 
   void checkPostStmt(const ObjCArrayLiteral *AL, CheckerContext &C) const;
   void checkPostStmt(const ObjCDictionaryLiteral *DL, CheckerContext &C) const;
   void checkPostStmt(const ObjCBoxedExpr *BE, CheckerContext &C) const;
 
   void checkPostStmt(const ObjCIvarRefExpr *IRE, CheckerContext &C) const;
 
   void checkPostCall(const CallEvent &Call, CheckerContext &C) const;
 
   void checkSummary(const RetainSummary &Summ, const CallEvent &Call,
                     CheckerContext &C) const;
 
   void processSummaryOfInlined(const RetainSummary &Summ,
                                const CallEvent &Call,
                                CheckerContext &C) const;
 
   bool evalCall(const CallExpr *CE, CheckerContext &C) const;
 
   ProgramStateRef evalAssume(ProgramStateRef state, SVal Cond,
                                  bool Assumption) const;
 
   ProgramStateRef
   checkRegionChanges(ProgramStateRef state,
                      const InvalidatedSymbols *invalidated,
                      ArrayRef<const MemRegion *> ExplicitRegions,
                      ArrayRef<const MemRegion *> Regions,
                      const LocationContext* LCtx,
                      const CallEvent *Call) const;
 
   ExplodedNode* checkReturnWithRetEffect(const ReturnStmt *S, CheckerContext &C,
                                 ExplodedNode *Pred, RetEffect RE, RefVal X,
                                 SymbolRef Sym, ProgramStateRef state) const;
 
   void checkDeadSymbols(SymbolReaper &SymReaper, CheckerContext &C) const;
   void checkBeginFunction(CheckerContext &C) const;
   void checkEndFunction(const ReturnStmt *RS, CheckerContext &C) const;
 
   ProgramStateRef updateSymbol(ProgramStateRef state, SymbolRef sym,
                                RefVal V, ArgEffect E, RefVal::Kind &hasErr,
                                CheckerContext &C) const;
 
   const RefCountBug &errorKindToBugKind(RefVal::Kind ErrorKind,
                                         SymbolRef Sym) const;
 
   void processNonLeakError(ProgramStateRef St, SourceRange ErrorRange,
                            RefVal::Kind ErrorKind, SymbolRef Sym,
                            CheckerContext &C) const;
 
   void processObjCLiterals(CheckerContext &C, const Expr *Ex) const;
 
   ProgramStateRef handleSymbolDeath(ProgramStateRef state,
                                     SymbolRef sid, RefVal V,
                                     SmallVectorImpl<SymbolRef> &Leaked) const;
 
   ProgramStateRef
   handleAutoreleaseCounts(ProgramStateRef state, ExplodedNode *Pred,
                           const ProgramPointTag *Tag, CheckerContext &Ctx,
                           SymbolRef Sym,
                           RefVal V,
                           const ReturnStmt *S=nullptr) const;
 
   ExplodedNode *processLeaks(ProgramStateRef state,
                              SmallVectorImpl<SymbolRef> &Leaked,
                              CheckerContext &Ctx,
                              ExplodedNode *Pred = nullptr) const;
 
   const CheckerProgramPointTag &getDeallocSentTag() const {
     return DeallocSentTag;
   }
 
   const CheckerProgramPointTag &getCastFailTag() const {
     return CastFailTag;
   }
 
 private:
   /// Perform the necessary checks and state adjustments at the end of the
   /// function.
   /// \p S Return statement, may be null.
   ExplodedNode * processReturn(const ReturnStmt *S, CheckerContext &C) const;
 };
 
 //===----------------------------------------------------------------------===//
 // RefBindings - State used to track object reference counts.
 //===----------------------------------------------------------------------===//
 
 const RefVal *getRefBinding(ProgramStateRef State, SymbolRef Sym);
 
 /// Returns true if this stack frame is for an Objective-C method that is a
 /// property getter or setter whose body has been synthesized by the analyzer.
 inline bool isSynthesizedAccessor(const StackFrameContext *SFC) {
   auto Method = dyn_cast_or_null<ObjCMethodDecl>(SFC->getDecl());
   if (!Method || !Method->isPropertyAccessor())
     return false;
 
   return SFC->getAnalysisDeclContext()->isBodyAutosynthesized();
 }
 
 } // end namespace retaincountchecker
 } // end namespace ento
 } // end namespace clang
 
 #endif
diff --git a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp
index dcb5ca855581..8e13ee35f3c4 100644
--- a/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp
+++ b/clang/lib/StaticAnalyzer/Checkers/RetainCountChecker/RetainCountDiagnostics.cpp
@@ -1,880 +1,924 @@
 // RetainCountDiagnostics.cpp - Checks for leaks and other issues -*- C++ -*--//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines diagnostics for RetainCountChecker, which implements
 //  a reference count checker for Core Foundation and Cocoa on (Mac OS X).
 //
 //===----------------------------------------------------------------------===//
 
 #include "RetainCountDiagnostics.h"
 #include "RetainCountChecker.h"
 
 using namespace clang;
 using namespace ento;
 using namespace retaincountchecker;
 
 StringRef RefCountBug::bugTypeToName(RefCountBug::RefCountBugType BT) {
   switch (BT) {
   case UseAfterRelease:
     return "Use-after-release";
   case ReleaseNotOwned:
     return "Bad release";
   case DeallocNotOwned:
     return "-dealloc sent to non-exclusively owned object";
   case FreeNotOwned:
     return "freeing non-exclusively owned object";
   case OverAutorelease:
     return "Object autoreleased too many times";
   case ReturnNotOwnedForOwned:
     return "Method should return an owned object";
   case LeakWithinFunction:
     return "Leak";
   case LeakAtReturn:
     return "Leak of returned object";
   }
   llvm_unreachable("Unknown RefCountBugType");
 }
 
 StringRef RefCountBug::getDescription() const {
   switch (BT) {
   case UseAfterRelease:
     return "Reference-counted object is used after it is released";
   case ReleaseNotOwned:
     return "Incorrect decrement of the reference count of an object that is "
            "not owned at this point by the caller";
   case DeallocNotOwned:
     return "-dealloc sent to object that may be referenced elsewhere";
   case FreeNotOwned:
     return  "'free' called on an object that may be referenced elsewhere";
   case OverAutorelease:
     return "Object autoreleased too many times";
   case ReturnNotOwnedForOwned:
     return "Object with a +0 retain count returned to caller where a +1 "
            "(owning) retain count is expected";
   case LeakWithinFunction:
   case LeakAtReturn:
     return "";
   }
   llvm_unreachable("Unknown RefCountBugType");
 }
 
 RefCountBug::RefCountBug(const CheckerBase *Checker, RefCountBugType BT)
     : BugType(Checker, bugTypeToName(BT), categories::MemoryRefCount,
               /*SupressOnSink=*/BT == LeakWithinFunction || BT == LeakAtReturn),
       BT(BT), Checker(Checker) {}
 
 static bool isNumericLiteralExpression(const Expr *E) {
   // FIXME: This set of cases was copied from SemaExprObjC.
   return isa<IntegerLiteral>(E) ||
          isa<CharacterLiteral>(E) ||
          isa<FloatingLiteral>(E) ||
          isa<ObjCBoolLiteralExpr>(E) ||
          isa<CXXBoolLiteralExpr>(E);
 }
 
 /// If type represents a pointer to CXXRecordDecl,
 /// and is not a typedef, return the decl name.
 /// Otherwise, return the serialization of type.
 static std::string getPrettyTypeName(QualType QT) {
   QualType PT = QT->getPointeeType();
   if (!PT.isNull() && !QT->getAs<TypedefType>())
     if (const auto *RD = PT->getAsCXXRecordDecl())
       return RD->getName();
   return QT.getAsString();
 }
 
 /// Write information about the type state change to {@code os},
 /// return whether the note should be generated.
 static bool shouldGenerateNote(llvm::raw_string_ostream &os,
                                const RefVal *PrevT,
                                const RefVal &CurrV,
                                bool DeallocSent) {
   // Get the previous type state.
   RefVal PrevV = *PrevT;
 
   // Specially handle -dealloc.
   if (DeallocSent) {
     // Determine if the object's reference count was pushed to zero.
     assert(!PrevV.hasSameState(CurrV) && "The state should have changed.");
     // We may not have transitioned to 'release' if we hit an error.
     // This case is handled elsewhere.
     if (CurrV.getKind() == RefVal::Released) {
       assert(CurrV.getCombinedCounts() == 0);
       os << "Object released by directly sending the '-dealloc' message";
       return true;
     }
   }
 
   // Determine if the typestate has changed.
   if (!PrevV.hasSameState(CurrV))
     switch (CurrV.getKind()) {
     case RefVal::Owned:
     case RefVal::NotOwned:
       if (PrevV.getCount() == CurrV.getCount()) {
         // Did an autorelease message get sent?
         if (PrevV.getAutoreleaseCount() == CurrV.getAutoreleaseCount())
           return false;
 
         assert(PrevV.getAutoreleaseCount() < CurrV.getAutoreleaseCount());
         os << "Object autoreleased";
         return true;
       }
 
       if (PrevV.getCount() > CurrV.getCount())
         os << "Reference count decremented.";
       else
         os << "Reference count incremented.";
 
       if (unsigned Count = CurrV.getCount())
         os << " The object now has a +" << Count << " retain count.";
 
       return true;
 
     case RefVal::Released:
       if (CurrV.getIvarAccessHistory() ==
               RefVal::IvarAccessHistory::ReleasedAfterDirectAccess &&
           CurrV.getIvarAccessHistory() != PrevV.getIvarAccessHistory()) {
         os << "Strong instance variable relinquished. ";
       }
       os << "Object released.";
       return true;
 
     case RefVal::ReturnedOwned:
       // Autoreleases can be applied after marking a node ReturnedOwned.
       if (CurrV.getAutoreleaseCount())
         return false;
 
       os << "Object returned to caller as an owning reference (single "
             "retain count transferred to caller)";
       return true;
 
     case RefVal::ReturnedNotOwned:
       os << "Object returned to caller with a +0 retain count";
       return true;
 
     default:
       return false;
     }
   return true;
 }
 
 /// Finds argument index of the out paramter in the call {@code S}
 /// corresponding to the symbol {@code Sym}.
 /// If none found, returns None.
 static Optional<unsigned> findArgIdxOfSymbol(ProgramStateRef CurrSt,
                                              const LocationContext *LCtx,
                                              SymbolRef &Sym,
                                              Optional<CallEventRef<>> CE) {
   if (!CE)
     return None;
 
   for (unsigned Idx = 0; Idx < (*CE)->getNumArgs(); Idx++)
     if (const MemRegion *MR = (*CE)->getArgSVal(Idx).getAsRegion())
       if (const auto *TR = dyn_cast<TypedValueRegion>(MR))
         if (CurrSt->getSVal(MR, TR->getValueType()).getAsSymExpr() == Sym)
           return Idx;
 
   return None;
 }
 
 Optional<std::string> findMetaClassAlloc(const Expr *Callee) {
   if (const auto *ME = dyn_cast<MemberExpr>(Callee)) {
     if (ME->getMemberDecl()->getNameAsString() != "alloc")
       return None;
     const Expr *This = ME->getBase()->IgnoreParenImpCasts();
     if (const auto *DRE = dyn_cast<DeclRefExpr>(This)) {
       const ValueDecl *VD = DRE->getDecl();
       if (VD->getNameAsString() != "metaClass")
         return None;
 
       if (const auto *RD = dyn_cast<CXXRecordDecl>(VD->getDeclContext()))
         return RD->getNameAsString();
 
     }
   }
   return None;
 }
 
 std::string findAllocatedObjectName(const Stmt *S,
                                     QualType QT) {
   if (const auto *CE = dyn_cast<CallExpr>(S))
     if (auto Out = findMetaClassAlloc(CE->getCallee()))
       return *Out;
   return getPrettyTypeName(QT);
 }
 
 static void generateDiagnosticsForCallLike(ProgramStateRef CurrSt,
                                            const LocationContext *LCtx,
                                            const RefVal &CurrV, SymbolRef &Sym,
                                            const Stmt *S,
                                            llvm::raw_string_ostream &os) {
   CallEventManager &Mgr = CurrSt->getStateManager().getCallEventManager();
   if (const CallExpr *CE = dyn_cast<CallExpr>(S)) {
     // Get the name of the callee (if it is available)
     // from the tracked SVal.
     SVal X = CurrSt->getSValAsScalarOrLoc(CE->getCallee(), LCtx);
     const FunctionDecl *FD = X.getAsFunctionDecl();
 
     // If failed, try to get it from AST.
     if (!FD)
       FD = dyn_cast<FunctionDecl>(CE->getCalleeDecl());
 
     if (const auto *MD = dyn_cast<CXXMethodDecl>(CE->getCalleeDecl())) {
       os << "Call to method '" << MD->getQualifiedNameAsString() << '\'';
     } else if (FD) {
       os << "Call to function '" << FD->getQualifiedNameAsString() << '\'';
     } else {
       os << "function call";
     }
   } else if (isa<CXXNewExpr>(S)) {
     os << "Operator 'new'";
   } else {
     assert(isa<ObjCMessageExpr>(S));
     CallEventRef<ObjCMethodCall> Call =
         Mgr.getObjCMethodCall(cast<ObjCMessageExpr>(S), CurrSt, LCtx);
 
     switch (Call->getMessageKind()) {
     case OCM_Message:
       os << "Method";
       break;
     case OCM_PropertyAccess:
       os << "Property";
       break;
     case OCM_Subscript:
       os << "Subscript";
       break;
     }
   }
 
   Optional<CallEventRef<>> CE = Mgr.getCall(S, CurrSt, LCtx);
   auto Idx = findArgIdxOfSymbol(CurrSt, LCtx, Sym, CE);
 
   // If index is not found, we assume that the symbol was returned.
   if (!Idx) {
     os << " returns ";
   } else {
     os << " writes ";
   }
 
   if (CurrV.getObjKind() == ObjKind::CF) {
     os << "a Core Foundation object of type '"
        << Sym->getType().getAsString() << "' with a ";
   } else if (CurrV.getObjKind() == ObjKind::OS) {
     os << "an OSObject of type '" << findAllocatedObjectName(S, Sym->getType())
        << "' with a ";
   } else if (CurrV.getObjKind() == ObjKind::Generalized) {
     os << "an object of type '" << Sym->getType().getAsString()
        << "' with a ";
   } else {
     assert(CurrV.getObjKind() == ObjKind::ObjC);
     QualType T = Sym->getType();
     if (!isa<ObjCObjectPointerType>(T)) {
       os << "an Objective-C object with a ";
     } else {
       const ObjCObjectPointerType *PT = cast<ObjCObjectPointerType>(T);
       os << "an instance of " << PT->getPointeeType().getAsString()
          << " with a ";
     }
   }
 
   if (CurrV.isOwned()) {
     os << "+1 retain count";
   } else {
     assert(CurrV.isNotOwned());
     os << "+0 retain count";
   }
 
   if (Idx) {
     os << " into an out parameter '";
     const ParmVarDecl *PVD = (*CE)->parameters()[*Idx];
     PVD->getNameForDiagnostic(os, PVD->getASTContext().getPrintingPolicy(),
                               /*Qualified=*/false);
     os << "'";
 
     QualType RT = (*CE)->getResultType();
     if (!RT.isNull() && !RT->isVoidType()) {
       SVal RV = (*CE)->getReturnValue();
       if (CurrSt->isNull(RV).isConstrainedTrue()) {
         os << " (assuming the call returns zero)";
       } else if (CurrSt->isNonNull(RV).isConstrainedTrue()) {
         os << " (assuming the call returns non-zero)";
       }
 
     }
   }
 }
 
 namespace clang {
 namespace ento {
 namespace retaincountchecker {
 
 class RefCountReportVisitor : public BugReporterVisitor {
 protected:
   SymbolRef Sym;
 
 public:
   RefCountReportVisitor(SymbolRef sym) : Sym(sym) {}
 
   void Profile(llvm::FoldingSetNodeID &ID) const override {
     static int x = 0;
     ID.AddPointer(&x);
     ID.AddPointer(Sym);
   }
 
   std::shared_ptr<PathDiagnosticPiece> VisitNode(const ExplodedNode *N,
                                                  BugReporterContext &BRC,
                                                  BugReport &BR) override;
 
   std::shared_ptr<PathDiagnosticPiece> getEndPath(BugReporterContext &BRC,
                                                   const ExplodedNode *N,
                                                   BugReport &BR) override;
 };
 
 class RefLeakReportVisitor : public RefCountReportVisitor {
 public:
   RefLeakReportVisitor(SymbolRef sym) : RefCountReportVisitor(sym) {}
 
   std::shared_ptr<PathDiagnosticPiece> getEndPath(BugReporterContext &BRC,
                                                   const ExplodedNode *N,
                                                   BugReport &BR) override;
 };
 
 } // end namespace retaincountchecker
 } // end namespace ento
 } // end namespace clang
 
 
 /// Find the first node with the parent stack frame.
 static const ExplodedNode *getCalleeNode(const ExplodedNode *Pred) {
   const StackFrameContext *SC = Pred->getStackFrame();
   if (SC->inTopFrame())
     return nullptr;
   const StackFrameContext *PC = SC->getParent()->getStackFrame();
   if (!PC)
     return nullptr;
 
   const ExplodedNode *N = Pred;
   while (N && N->getStackFrame() != PC) {
     N = N->getFirstPred();
   }
   return N;
 }
 
 
 /// Insert a diagnostic piece at function exit
 /// if a function parameter is annotated as "os_consumed",
 /// but it does not actually consume the reference.
 static std::shared_ptr<PathDiagnosticEventPiece>
 annotateConsumedSummaryMismatch(const ExplodedNode *N,
                                 CallExitBegin &CallExitLoc,
                                 const SourceManager &SM,
                                 CallEventManager &CEMgr) {
 
   const ExplodedNode *CN = getCalleeNode(N);
   if (!CN)
     return nullptr;
 
   CallEventRef<> Call = CEMgr.getCaller(N->getStackFrame(), N->getState());
 
   std::string sbuf;
   llvm::raw_string_ostream os(sbuf);
   ArrayRef<const ParmVarDecl *> Parameters = Call->parameters();
   for (unsigned I=0; I < Call->getNumArgs() && I < Parameters.size(); ++I) {
     const ParmVarDecl *PVD = Parameters[I];
 
     if (!PVD->hasAttr<OSConsumedAttr>())
       continue;
 
     if (SymbolRef SR = Call->getArgSVal(I).getAsLocSymbol()) {
       const RefVal *CountBeforeCall = getRefBinding(CN->getState(), SR);
       const RefVal *CountAtExit = getRefBinding(N->getState(), SR);
 
       if (!CountBeforeCall || !CountAtExit)
         continue;
 
       unsigned CountBefore = CountBeforeCall->getCount();
       unsigned CountAfter = CountAtExit->getCount();
 
       bool AsExpected = CountBefore > 0 && CountAfter == CountBefore - 1;
       if (!AsExpected) {
         os << "Parameter '";
         PVD->getNameForDiagnostic(os, PVD->getASTContext().getPrintingPolicy(),
                                   /*Qualified=*/false);
         os << "' is marked as consuming, but the function did not consume "
            << "the reference\n";
       }
     }
   }
 
   if (os.str().empty())
     return nullptr;
 
   PathDiagnosticLocation L = PathDiagnosticLocation::create(CallExitLoc, SM);
   return std::make_shared<PathDiagnosticEventPiece>(L, os.str());
 }
 
+/// Annotate the parameter at the analysis entry point.
+static std::shared_ptr<PathDiagnosticEventPiece>
+annotateStartParameter(const ExplodedNode *N, SymbolRef Sym,
+                       const SourceManager &SM) {
+  auto PP = N->getLocationAs<BlockEdge>();
+  if (!PP)
+    return nullptr;
+
+  const CFGBlock *Src = PP->getSrc();
+  const RefVal *CurrT = getRefBinding(N->getState(), Sym);
+
+  if (&Src->getParent()->getEntry() != Src || !CurrT ||
+      getRefBinding(N->getFirstPred()->getState(), Sym))
+    return nullptr;
+
+  const auto *VR = cast<VarRegion>(cast<SymbolRegionValue>(Sym)->getRegion());
+  const auto *PVD = cast<ParmVarDecl>(VR->getDecl());
+  PathDiagnosticLocation L = PathDiagnosticLocation(PVD, SM);
+
+  std::string s;
+  llvm::raw_string_ostream os(s);
+  os << "Parameter '" << PVD->getNameAsString()
+    << "' starts at +";
+  if (CurrT->getCount() == 1) {
+    os << "1, as it is marked as consuming";
+  } else {
+    assert(CurrT->getCount() == 0);
+    os << "0";
+  }
+  return std::make_shared<PathDiagnosticEventPiece>(L, os.str());
+}
+
 std::shared_ptr<PathDiagnosticPiece>
 RefCountReportVisitor::VisitNode(const ExplodedNode *N,
                               BugReporterContext &BRC, BugReport &BR) {
 
   const auto &BT = static_cast<const RefCountBug&>(BR.getBugType());
   const auto *Checker =
       static_cast<const RetainCountChecker *>(BT.getChecker());
 
   bool IsFreeUnowned = BT.getBugType() == RefCountBug::FreeNotOwned ||
                        BT.getBugType() == RefCountBug::DeallocNotOwned;
 
   const SourceManager &SM = BRC.getSourceManager();
   CallEventManager &CEMgr = BRC.getStateManager().getCallEventManager();
   if (auto CE = N->getLocationAs<CallExitBegin>())
     if (auto PD = annotateConsumedSummaryMismatch(N, *CE, SM, CEMgr))
       return PD;
 
+  if (auto PD = annotateStartParameter(N, Sym, SM))
+    return PD;
+
   // FIXME: We will eventually need to handle non-statement-based events
   // (__attribute__((cleanup))).
   if (!N->getLocation().getAs<StmtPoint>())
     return nullptr;
 
   // Check if the type state has changed.
   const ExplodedNode *PrevNode = N->getFirstPred();
   ProgramStateRef PrevSt = PrevNode->getState();
   ProgramStateRef CurrSt = N->getState();
   const LocationContext *LCtx = N->getLocationContext();
 
   const RefVal* CurrT = getRefBinding(CurrSt, Sym);
   if (!CurrT)
     return nullptr;
 
   const RefVal &CurrV = *CurrT;
   const RefVal *PrevT = getRefBinding(PrevSt, Sym);
 
   // Create a string buffer to constain all the useful things we want
   // to tell the user.
   std::string sbuf;
   llvm::raw_string_ostream os(sbuf);
 
   if (PrevT && IsFreeUnowned && CurrV.isNotOwned() && PrevT->isOwned()) {
     os << "Object is now not exclusively owned";
     auto Pos = PathDiagnosticLocation::create(N->getLocation(), SM);
     return std::make_shared<PathDiagnosticEventPiece>(Pos, os.str());
   }
 
   // This is the allocation site since the previous node had no bindings
   // for this symbol.
   if (!PrevT) {
     const Stmt *S = N->getLocation().castAs<StmtPoint>().getStmt();
 
     if (isa<ObjCIvarRefExpr>(S) &&
         isSynthesizedAccessor(LCtx->getStackFrame())) {
       S = LCtx->getStackFrame()->getCallSite();
     }
 
     if (isa<ObjCArrayLiteral>(S)) {
       os << "NSArray literal is an object with a +0 retain count";
     } else if (isa<ObjCDictionaryLiteral>(S)) {
       os << "NSDictionary literal is an object with a +0 retain count";
     } else if (const ObjCBoxedExpr *BL = dyn_cast<ObjCBoxedExpr>(S)) {
       if (isNumericLiteralExpression(BL->getSubExpr()))
         os << "NSNumber literal is an object with a +0 retain count";
       else {
         const ObjCInterfaceDecl *BoxClass = nullptr;
         if (const ObjCMethodDecl *Method = BL->getBoxingMethod())
           BoxClass = Method->getClassInterface();
 
         // We should always be able to find the boxing class interface,
         // but consider this future-proofing.
         if (BoxClass) {
           os << *BoxClass << " b";
         } else {
           os << "B";
         }
 
         os << "oxed expression produces an object with a +0 retain count";
       }
     } else if (isa<ObjCIvarRefExpr>(S)) {
       os << "Object loaded from instance variable";
     } else {
       generateDiagnosticsForCallLike(CurrSt, LCtx, CurrV, Sym, S, os);
     }
 
     PathDiagnosticLocation Pos(S, SM, N->getLocationContext());
     return std::make_shared<PathDiagnosticEventPiece>(Pos, os.str());
   }
 
   // Gather up the effects that were performed on the object at this
   // program point
   bool DeallocSent = false;
 
   const ProgramPointTag *Tag = N->getLocation().getTag();
 
   if (Tag == &Checker->getCastFailTag()) {
     os << "Assuming dynamic cast returns null due to type mismatch";
   }
 
   if (Tag == &Checker->getDeallocSentTag()) {
     // We only have summaries attached to nodes after evaluating CallExpr and
     // ObjCMessageExprs.
     const Stmt *S = N->getLocation().castAs<StmtPoint>().getStmt();
 
     if (const CallExpr *CE = dyn_cast<CallExpr>(S)) {
       // Iterate through the parameter expressions and see if the symbol
       // was ever passed as an argument.
       unsigned i = 0;
 
       for (auto AI=CE->arg_begin(), AE=CE->arg_end(); AI!=AE; ++AI, ++i) {
 
         // Retrieve the value of the argument.  Is it the symbol
         // we are interested in?
         if (CurrSt->getSValAsScalarOrLoc(*AI, LCtx).getAsLocSymbol() != Sym)
           continue;
 
         // We have an argument.  Get the effect!
         DeallocSent = true;
       }
     } else if (const ObjCMessageExpr *ME = dyn_cast<ObjCMessageExpr>(S)) {
       if (const Expr *receiver = ME->getInstanceReceiver()) {
         if (CurrSt->getSValAsScalarOrLoc(receiver, LCtx)
               .getAsLocSymbol() == Sym) {
           // The symbol we are tracking is the receiver.
           DeallocSent = true;
         }
       }
     }
   }
 
   if (!shouldGenerateNote(os, PrevT, CurrV, DeallocSent))
     return nullptr;
 
   if (os.str().empty())
     return nullptr; // We have nothing to say!
 
   const Stmt *S = N->getLocation().castAs<StmtPoint>().getStmt();
   PathDiagnosticLocation Pos(S, BRC.getSourceManager(),
                                 N->getLocationContext());
   auto P = std::make_shared<PathDiagnosticEventPiece>(Pos, os.str());
 
   // Add the range by scanning the children of the statement for any bindings
   // to Sym.
   for (const Stmt *Child : S->children())
     if (const Expr *Exp = dyn_cast_or_null<Expr>(Child))
       if (CurrSt->getSValAsScalarOrLoc(Exp, LCtx).getAsLocSymbol() == Sym) {
         P->addRange(Exp->getSourceRange());
         break;
       }
 
   return std::move(P);
 }
 
 static Optional<std::string> describeRegion(const MemRegion *MR) {
   if (const auto *VR = dyn_cast_or_null<VarRegion>(MR))
     return std::string(VR->getDecl()->getName());
   // Once we support more storage locations for bindings,
   // this would need to be improved.
   return None;
 }
 
 namespace {
 // Find the first node in the current function context that referred to the
 // tracked symbol and the memory location that value was stored to. Note, the
 // value is only reported if the allocation occurred in the same function as
 // the leak. The function can also return a location context, which should be
 // treated as interesting.
 struct AllocationInfo {
   const ExplodedNode* N;
   const MemRegion *R;
   const LocationContext *InterestingMethodContext;
   AllocationInfo(const ExplodedNode *InN,
                  const MemRegion *InR,
                  const LocationContext *InInterestingMethodContext) :
     N(InN), R(InR), InterestingMethodContext(InInterestingMethodContext) {}
 };
 } // end anonymous namespace
 
 static AllocationInfo GetAllocationSite(ProgramStateManager &StateMgr,
                                         const ExplodedNode *N, SymbolRef Sym) {
   const ExplodedNode *AllocationNode = N;
   const ExplodedNode *AllocationNodeInCurrentOrParentContext = N;
   const MemRegion *FirstBinding = nullptr;
   const LocationContext *LeakContext = N->getLocationContext();
 
   // The location context of the init method called on the leaked object, if
   // available.
   const LocationContext *InitMethodContext = nullptr;
 
   while (N) {
     ProgramStateRef St = N->getState();
     const LocationContext *NContext = N->getLocationContext();
 
     if (!getRefBinding(St, Sym))
       break;
 
     StoreManager::FindUniqueBinding FB(Sym);
     StateMgr.iterBindings(St, FB);
 
     if (FB) {
       const MemRegion *R = FB.getRegion();
       // Do not show local variables belonging to a function other than
       // where the error is reported.
       if (auto MR = dyn_cast<StackSpaceRegion>(R->getMemorySpace()))
         if (MR->getStackFrame() == LeakContext->getStackFrame())
           FirstBinding = R;
     }
 
     // AllocationNode is the last node in which the symbol was tracked.
     AllocationNode = N;
 
     // AllocationNodeInCurrentContext, is the last node in the current or
     // parent context in which the symbol was tracked.
     //
     // Note that the allocation site might be in the parent context. For example,
     // the case where an allocation happens in a block that captures a reference
     // to it and that reference is overwritten/dropped by another call to
     // the block.
     if (NContext == LeakContext || NContext->isParentOf(LeakContext))
       AllocationNodeInCurrentOrParentContext = N;
 
     // Find the last init that was called on the given symbol and store the
     // init method's location context.
     if (!InitMethodContext)
       if (auto CEP = N->getLocation().getAs<CallEnter>()) {
         const Stmt *CE = CEP->getCallExpr();
         if (const auto *ME = dyn_cast_or_null<ObjCMessageExpr>(CE)) {
           const Stmt *RecExpr = ME->getInstanceReceiver();
           if (RecExpr) {
             SVal RecV = St->getSVal(RecExpr, NContext);
             if (ME->getMethodFamily() == OMF_init && RecV.getAsSymbol() == Sym)
               InitMethodContext = CEP->getCalleeContext();
           }
         }
       }
 
     N = N->getFirstPred();
   }
 
   // If we are reporting a leak of the object that was allocated with alloc,
   // mark its init method as interesting.
   const LocationContext *InterestingMethodContext = nullptr;
   if (InitMethodContext) {
     const ProgramPoint AllocPP = AllocationNode->getLocation();
     if (Optional<StmtPoint> SP = AllocPP.getAs<StmtPoint>())
       if (const ObjCMessageExpr *ME = SP->getStmtAs<ObjCMessageExpr>())
         if (ME->getMethodFamily() == OMF_alloc)
           InterestingMethodContext = InitMethodContext;
   }
 
   // If allocation happened in a function different from the leak node context,
   // do not report the binding.
   assert(N && "Could not find allocation node");
 
   if (AllocationNodeInCurrentOrParentContext &&
       AllocationNodeInCurrentOrParentContext->getLocationContext() !=
-          LeakContext)
+      LeakContext)
     FirstBinding = nullptr;
 
   return AllocationInfo(AllocationNodeInCurrentOrParentContext,
                         FirstBinding,
                         InterestingMethodContext);
 }
 
 std::shared_ptr<PathDiagnosticPiece>
 RefCountReportVisitor::getEndPath(BugReporterContext &BRC,
                                const ExplodedNode *EndN, BugReport &BR) {
   BR.markInteresting(Sym);
   return BugReporterVisitor::getDefaultEndPath(BRC, EndN, BR);
 }
 
 std::shared_ptr<PathDiagnosticPiece>
 RefLeakReportVisitor::getEndPath(BugReporterContext &BRC,
                                    const ExplodedNode *EndN, BugReport &BR) {
 
   // Tell the BugReporterContext to report cases when the tracked symbol is
   // assigned to different variables, etc.
   BR.markInteresting(Sym);
 
   // We are reporting a leak.  Walk up the graph to get to the first node where
   // the symbol appeared, and also get the first VarDecl that tracked object
   // is stored to.
   AllocationInfo AllocI = GetAllocationSite(BRC.getStateManager(), EndN, Sym);
 
   const MemRegion* FirstBinding = AllocI.R;
   BR.markInteresting(AllocI.InterestingMethodContext);
 
   SourceManager& SM = BRC.getSourceManager();
 
   // Compute an actual location for the leak.  Sometimes a leak doesn't
   // occur at an actual statement (e.g., transition between blocks; end
   // of function) so we need to walk the graph and compute a real location.
   const ExplodedNode *LeakN = EndN;
   PathDiagnosticLocation L = PathDiagnosticLocation::createEndOfPath(LeakN, SM);
 
   std::string sbuf;
   llvm::raw_string_ostream os(sbuf);
 
   os << "Object leaked: ";
 
   Optional<std::string> RegionDescription = describeRegion(FirstBinding);
   if (RegionDescription) {
     os << "object allocated and stored into '" << *RegionDescription << '\'';
   } else {
     os << "allocated object of type '" << getPrettyTypeName(Sym->getType())
        << "'";
   }
 
   // Get the retain count.
   const RefVal* RV = getRefBinding(EndN->getState(), Sym);
   assert(RV);
 
   if (RV->getKind() == RefVal::ErrorLeakReturned) {
     // FIXME: Per comments in rdar://6320065, "create" only applies to CF
     // objects.  Only "copy", "alloc", "retain" and "new" transfer ownership
     // to the caller for NS objects.
     const Decl *D = &EndN->getCodeDecl();
 
     os << (isa<ObjCMethodDecl>(D) ? " is returned from a method "
                                   : " is returned from a function ");
 
     if (D->hasAttr<CFReturnsNotRetainedAttr>()) {
       os << "that is annotated as CF_RETURNS_NOT_RETAINED";
     } else if (D->hasAttr<NSReturnsNotRetainedAttr>()) {
       os << "that is annotated as NS_RETURNS_NOT_RETAINED";
     } else if (D->hasAttr<OSReturnsNotRetainedAttr>()) {
       os << "that is annotated as OS_RETURNS_NOT_RETAINED";
     } else {
       if (const ObjCMethodDecl *MD = dyn_cast<ObjCMethodDecl>(D)) {
         if (BRC.getASTContext().getLangOpts().ObjCAutoRefCount) {
           os << "managed by Automatic Reference Counting";
         } else {
           os << "whose name ('" << MD->getSelector().getAsString()
              << "') does not start with "
                 "'copy', 'mutableCopy', 'alloc' or 'new'."
                 "  This violates the naming convention rules"
                 " given in the Memory Management Guide for Cocoa";
         }
       } else {
         const FunctionDecl *FD = cast<FunctionDecl>(D);
-        os << "whose name ('" << *FD
-           << "') does not contain 'Copy' or 'Create'.  This violates the naming"
-              " convention rules given in the Memory Management Guide for Core"
-              " Foundation";
+        ObjKind K = RV->getObjKind();
+        if (K == ObjKind::ObjC || K == ObjKind::CF) {
+          os << "whose name ('" << *FD
+             << "') does not contain 'Copy' or 'Create'.  This violates the "
+                "naming"
+                " convention rules given in the Memory Management Guide for "
+                "Core"
+                " Foundation";
+        } else if (RV->getObjKind() == ObjKind::OS) {
+          std::string FuncName = FD->getNameAsString();
+          os << "whose name ('" << FuncName
+            << "') starts with '" << StringRef(FuncName).substr(0, 3) << "'";
+        }
       }
     }
   } else {
     os << " is not referenced later in this execution path and has a retain "
           "count of +" << RV->getCount();
   }
 
   return std::make_shared<PathDiagnosticEventPiece>(L, os.str());
 }
 
 RefCountReport::RefCountReport(const RefCountBug &D, const LangOptions &LOpts,
                                ExplodedNode *n, SymbolRef sym,
                                bool isLeak)
     : BugReport(D, D.getDescription(), n), Sym(sym), isLeak(isLeak) {
   if (!isLeak)
     addVisitor(llvm::make_unique<RefCountReportVisitor>(sym));
 }
 
 RefCountReport::RefCountReport(const RefCountBug &D, const LangOptions &LOpts,
                                ExplodedNode *n, SymbolRef sym,
                                StringRef endText)
     : BugReport(D, D.getDescription(), endText, n) {
 
   addVisitor(llvm::make_unique<RefCountReportVisitor>(sym));
 }
 
 void RefLeakReport::deriveParamLocation(CheckerContext &Ctx, SymbolRef sym) {
   const SourceManager& SMgr = Ctx.getSourceManager();
 
   if (!sym->getOriginRegion())
     return;
 
   auto *Region = dyn_cast<DeclRegion>(sym->getOriginRegion());
   if (Region) {
     const Decl *PDecl = Region->getDecl();
     if (PDecl && isa<ParmVarDecl>(PDecl)) {
       PathDiagnosticLocation ParamLocation =
           PathDiagnosticLocation::create(PDecl, SMgr);
       Location = ParamLocation;
       UniqueingLocation = ParamLocation;
       UniqueingDecl = Ctx.getLocationContext()->getDecl();
     }
   }
 }
 
 void RefLeakReport::deriveAllocLocation(CheckerContext &Ctx,
                                           SymbolRef sym) {
   // Most bug reports are cached at the location where they occurred.
   // With leaks, we want to unique them by the location where they were
   // allocated, and only report a single path.  To do this, we need to find
   // the allocation site of a piece of tracked memory, which we do via a
   // call to GetAllocationSite.  This will walk the ExplodedGraph backwards.
   // Note that this is *not* the trimmed graph; we are guaranteed, however,
   // that all ancestor nodes that represent the allocation site have the
   // same SourceLocation.
   const ExplodedNode *AllocNode = nullptr;
 
   const SourceManager& SMgr = Ctx.getSourceManager();
 
   AllocationInfo AllocI =
       GetAllocationSite(Ctx.getStateManager(), getErrorNode(), sym);
 
   AllocNode = AllocI.N;
   AllocBinding = AllocI.R;
   markInteresting(AllocI.InterestingMethodContext);
 
   // Get the SourceLocation for the allocation site.
   // FIXME: This will crash the analyzer if an allocation comes from an
   // implicit call (ex: a destructor call).
   // (Currently there are no such allocations in Cocoa, though.)
   AllocStmt = PathDiagnosticLocation::getStmt(AllocNode);
 
   if (!AllocStmt) {
     AllocBinding = nullptr;
     return;
   }
 
   PathDiagnosticLocation AllocLocation =
     PathDiagnosticLocation::createBegin(AllocStmt, SMgr,
                                         AllocNode->getLocationContext());
   Location = AllocLocation;
 
   // Set uniqieing info, which will be used for unique the bug reports. The
   // leaks should be uniqued on the allocation site.
   UniqueingLocation = AllocLocation;
   UniqueingDecl = AllocNode->getLocationContext()->getDecl();
 }
 
 void RefLeakReport::createDescription(CheckerContext &Ctx) {
   assert(Location.isValid() && UniqueingDecl && UniqueingLocation.isValid());
   Description.clear();
   llvm::raw_string_ostream os(Description);
   os << "Potential leak of an object";
 
   Optional<std::string> RegionDescription = describeRegion(AllocBinding);
   if (RegionDescription) {
     os << " stored into '" << *RegionDescription << '\'';
   } else {
 
     // If we can't figure out the name, just supply the type information.
     os << " of type '" << getPrettyTypeName(Sym->getType()) << "'";
   }
 }
 
 RefLeakReport::RefLeakReport(const RefCountBug &D, const LangOptions &LOpts,
                              ExplodedNode *n, SymbolRef sym,
                              CheckerContext &Ctx)
     : RefCountReport(D, LOpts, n, sym, /*isLeak=*/true) {
 
   deriveAllocLocation(Ctx, sym);
   if (!AllocBinding)
     deriveParamLocation(Ctx, sym);
 
   createDescription(Ctx);
 
   addVisitor(llvm::make_unique<RefLeakReportVisitor>(sym));
 }
diff --git a/clang/test/Analysis/Inputs/expected-plists/retain-release.m.objc.plist b/clang/test/Analysis/Inputs/expected-plists/retain-release.m.objc.plist
index def9a4a3cc93..00c651f1fdd1 100644
--- a/clang/test/Analysis/Inputs/expected-plists/retain-release.m.objc.plist
+++ b/clang/test/Analysis/Inputs/expected-plists/retain-release.m.objc.plist
@@ -1,26111 +1,26111 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
  <key>clang_version</key>
  <key>diagnostics</key>
  <array>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>348</integer>
+           <key>line</key><integer>355</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>348</integer>
+           <key>line</key><integer>355</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>349</integer>
+           <key>line</key><integer>356</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>349</integer>
+           <key>line</key><integer>356</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>349</integer>
+      <key>line</key><integer>356</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>349</integer>
+         <key>line</key><integer>356</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>349</integer>
+         <key>line</key><integer>356</integer>
          <key>col</key><integer>37</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>349</integer>
+           <key>line</key><integer>356</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>349</integer>
+           <key>line</key><integer>356</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>350</integer>
+           <key>line</key><integer>357</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>350</integer>
+           <key>line</key><integer>357</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>350</integer>
+      <key>line</key><integer>357</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>350</integer>
+         <key>line</key><integer>357</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>350</integer>
+         <key>line</key><integer>357</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>350</integer>
+         <key>line</key><integer>357</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>350</integer>
+         <key>line</key><integer>357</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +2 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +2 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>350</integer>
+           <key>line</key><integer>357</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>350</integer>
+           <key>line</key><integer>357</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>351</integer>
+           <key>line</key><integer>358</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>351</integer>
+           <key>line</key><integer>358</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>351</integer>
+      <key>line</key><integer>358</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>351</integer>
+         <key>line</key><integer>358</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>351</integer>
+         <key>line</key><integer>358</integer>
          <key>col</key><integer>17</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>351</integer>
+         <key>line</key><integer>358</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>351</integer>
+         <key>line</key><integer>358</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count decremented. The object now has a +1 retain count</string>
      <key>message</key>
      <string>Reference count decremented. The object now has a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>351</integer>
+           <key>line</key><integer>358</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>351</integer>
+           <key>line</key><integer>358</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>353</integer>
+           <key>line</key><integer>360</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>353</integer>
+           <key>line</key><integer>360</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>353</integer>
+      <key>line</key><integer>360</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>353</integer>
+         <key>line</key><integer>360</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>353</integer>
+         <key>line</key><integer>360</integer>
          <key>col</key><integer>17</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>353</integer>
+         <key>line</key><integer>360</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>353</integer>
+         <key>line</key><integer>360</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object released</string>
      <key>message</key>
      <string>Object released</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>353</integer>
+           <key>line</key><integer>360</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>353</integer>
+           <key>line</key><integer>360</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>354</integer>
+           <key>line</key><integer>361</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>354</integer>
+           <key>line</key><integer>361</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>354</integer>
+           <key>line</key><integer>361</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>354</integer>
+           <key>line</key><integer>361</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>354</integer>
+           <key>line</key><integer>361</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>354</integer>
+           <key>line</key><integer>361</integer>
            <key>col</key><integer>27</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>354</integer>
+      <key>line</key><integer>361</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>354</integer>
+         <key>line</key><integer>361</integer>
          <key>col</key><integer>29</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>354</integer>
+         <key>line</key><integer>361</integer>
          <key>col</key><integer>32</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference-counted object is used after it is released</string>
      <key>message</key>
      <string>Reference-counted object is used after it is released</string>
     </dict>
    </array>
    <key>description</key><string>Reference-counted object is used after it is released</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Use-after-release</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>1089a297e77ff0c9d2d55cfb3aae26d3</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f1</string>
   <key>issue_hash_function_offset</key><string>7</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>354</integer>
+   <key>line</key><integer>361</integer>
    <key>col</key><integer>7</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>347</integer>
-    <integer>348</integer>
-    <integer>349</integer>
-    <integer>350</integer>
-    <integer>351</integer>
-    <integer>352</integer>
-    <integer>353</integer>
     <integer>354</integer>
+    <integer>355</integer>
+    <integer>356</integer>
+    <integer>357</integer>
+    <integer>358</integer>
+    <integer>359</integer>
+    <integer>360</integer>
+    <integer>361</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>359</integer>
+           <key>line</key><integer>366</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>359</integer>
+           <key>line</key><integer>366</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>360</integer>
+           <key>line</key><integer>367</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>360</integer>
+           <key>line</key><integer>367</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>360</integer>
+      <key>line</key><integer>367</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>360</integer>
+         <key>line</key><integer>367</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>360</integer>
+         <key>line</key><integer>367</integer>
          <key>col</key><integer>37</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>360</integer>
+           <key>line</key><integer>367</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>360</integer>
+           <key>line</key><integer>367</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>361</integer>
+           <key>line</key><integer>368</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>361</integer>
+           <key>line</key><integer>368</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>361</integer>
+      <key>line</key><integer>368</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>361</integer>
+         <key>line</key><integer>368</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>361</integer>
+         <key>line</key><integer>368</integer>
          <key>col</key><integer>27</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>361</integer>
+         <key>line</key><integer>368</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>361</integer>
+         <key>line</key><integer>368</integer>
          <key>col</key><integer>19</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +2 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +2 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>361</integer>
+           <key>line</key><integer>368</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>361</integer>
+           <key>line</key><integer>368</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>362</integer>
+           <key>line</key><integer>369</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>362</integer>
+           <key>line</key><integer>369</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>362</integer>
+      <key>line</key><integer>369</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>362</integer>
+         <key>line</key><integer>369</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>362</integer>
+         <key>line</key><integer>369</integer>
          <key>col</key><integer>17</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>362</integer>
+         <key>line</key><integer>369</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>362</integer>
+         <key>line</key><integer>369</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count decremented. The object now has a +1 retain count</string>
      <key>message</key>
      <string>Reference count decremented. The object now has a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>362</integer>
+           <key>line</key><integer>369</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>362</integer>
+           <key>line</key><integer>369</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>364</integer>
+           <key>line</key><integer>371</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>364</integer>
+           <key>line</key><integer>371</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>364</integer>
+      <key>line</key><integer>371</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>364</integer>
+         <key>line</key><integer>371</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>364</integer>
+         <key>line</key><integer>371</integer>
          <key>col</key><integer>28</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>364</integer>
+         <key>line</key><integer>371</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>364</integer>
+         <key>line</key><integer>371</integer>
          <key>col</key><integer>19</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object released</string>
      <key>message</key>
      <string>Object released</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>364</integer>
+           <key>line</key><integer>371</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>364</integer>
+           <key>line</key><integer>371</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>365</integer>
+           <key>line</key><integer>372</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>365</integer>
+           <key>line</key><integer>372</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>365</integer>
+           <key>line</key><integer>372</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>365</integer>
+           <key>line</key><integer>372</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>365</integer>
+           <key>line</key><integer>372</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>365</integer>
+           <key>line</key><integer>372</integer>
            <key>col</key><integer>27</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>365</integer>
+      <key>line</key><integer>372</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>365</integer>
+         <key>line</key><integer>372</integer>
          <key>col</key><integer>29</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>365</integer>
+         <key>line</key><integer>372</integer>
          <key>col</key><integer>32</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference-counted object is used after it is released</string>
      <key>message</key>
      <string>Reference-counted object is used after it is released</string>
     </dict>
    </array>
    <key>description</key><string>Reference-counted object is used after it is released</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Use-after-release</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>bb12c99d56657635b20d4a0801590eed</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f2</string>
   <key>issue_hash_function_offset</key><string>7</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>365</integer>
+   <key>line</key><integer>372</integer>
    <key>col</key><integer>7</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>358</integer>
-    <integer>359</integer>
-    <integer>360</integer>
-    <integer>361</integer>
-    <integer>362</integer>
-    <integer>363</integer>
-    <integer>364</integer>
     <integer>365</integer>
+    <integer>366</integer>
+    <integer>367</integer>
+    <integer>368</integer>
+    <integer>369</integer>
+    <integer>370</integer>
+    <integer>371</integer>
+    <integer>372</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>395</integer>
+           <key>line</key><integer>402</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>395</integer>
+           <key>line</key><integer>402</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>396</integer>
+           <key>line</key><integer>403</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>396</integer>
+           <key>line</key><integer>403</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>396</integer>
+      <key>line</key><integer>403</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>396</integer>
+         <key>line</key><integer>403</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>396</integer>
+         <key>line</key><integer>403</integer>
          <key>col</key><integer>37</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>396</integer>
+           <key>line</key><integer>403</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>396</integer>
+           <key>line</key><integer>403</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>398</integer>
+           <key>line</key><integer>405</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>398</integer>
+           <key>line</key><integer>405</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>398</integer>
+           <key>line</key><integer>405</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>398</integer>
+           <key>line</key><integer>405</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>398</integer>
+           <key>line</key><integer>405</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>398</integer>
+           <key>line</key><integer>405</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>398</integer>
+      <key>line</key><integer>405</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>398</integer>
+         <key>line</key><integer>405</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>398</integer>
+         <key>line</key><integer>405</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;x&apos; is 0</string>
      <key>message</key>
      <string>Assuming &apos;x&apos; is 0</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>398</integer>
+           <key>line</key><integer>405</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>398</integer>
+           <key>line</key><integer>405</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>401</integer>
+           <key>line</key><integer>408</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>401</integer>
+           <key>line</key><integer>408</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>401</integer>
+           <key>line</key><integer>408</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>401</integer>
+           <key>line</key><integer>408</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>401</integer>
+           <key>line</key><integer>408</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>401</integer>
+           <key>line</key><integer>408</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>401</integer>
+      <key>line</key><integer>408</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>401</integer>
+         <key>line</key><integer>408</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>401</integer>
+         <key>line</key><integer>408</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;date&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;date&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;date&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>0e9bb151f425535a0ec1b0bf0574dd7d</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f5</string>
   <key>issue_hash_function_offset</key><string>2</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>401</integer>
+   <key>line</key><integer>408</integer>
    <key>col</key><integer>10</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>394</integer>
-    <integer>395</integer>
-    <integer>396</integer>
-    <integer>398</integer>
     <integer>401</integer>
+    <integer>402</integer>
+    <integer>403</integer>
+    <integer>405</integer>
+    <integer>408</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>407</integer>
+      <key>line</key><integer>414</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>407</integer>
+         <key>line</key><integer>414</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>407</integer>
+         <key>line</key><integer>414</integer>
          <key>col</key><integer>62</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>407</integer>
+           <key>line</key><integer>414</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>407</integer>
+           <key>line</key><integer>414</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>408</integer>
+           <key>line</key><integer>415</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>408</integer>
+           <key>line</key><integer>415</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>408</integer>
+      <key>line</key><integer>415</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>408</integer>
+         <key>line</key><integer>415</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>408</integer>
+         <key>line</key><integer>415</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>408</integer>
+         <key>line</key><integer>415</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>408</integer>
+         <key>line</key><integer>415</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +2 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +2 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>408</integer>
+           <key>line</key><integer>415</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>408</integer>
+           <key>line</key><integer>415</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>409</integer>
+           <key>line</key><integer>416</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>409</integer>
+           <key>line</key><integer>416</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>409</integer>
+      <key>line</key><integer>416</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>409</integer>
+         <key>line</key><integer>416</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>409</integer>
+         <key>line</key><integer>416</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;date&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;date&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;date&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>ad4b758c93bbe7feeee349a526293527</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f6</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>409</integer>
+   <key>line</key><integer>416</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>406</integer>
-    <integer>407</integer>
-    <integer>408</integer>
-    <integer>409</integer>
+    <integer>413</integer>
+    <integer>414</integer>
+    <integer>415</integer>
+    <integer>416</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>415</integer>
+      <key>line</key><integer>422</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>415</integer>
+         <key>line</key><integer>422</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>415</integer>
+         <key>line</key><integer>422</integer>
          <key>col</key><integer>62</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>415</integer>
+           <key>line</key><integer>422</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>415</integer>
+           <key>line</key><integer>422</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>416</integer>
+           <key>line</key><integer>423</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>416</integer>
+           <key>line</key><integer>423</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>416</integer>
+      <key>line</key><integer>423</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>416</integer>
+         <key>line</key><integer>423</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>416</integer>
+         <key>line</key><integer>423</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>416</integer>
+         <key>line</key><integer>423</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>416</integer>
+         <key>line</key><integer>423</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +2 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +2 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>416</integer>
+           <key>line</key><integer>423</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>416</integer>
+           <key>line</key><integer>423</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>418</integer>
+           <key>line</key><integer>425</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>418</integer>
+           <key>line</key><integer>425</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>418</integer>
+      <key>line</key><integer>425</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>418</integer>
+         <key>line</key><integer>425</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>418</integer>
+         <key>line</key><integer>425</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;date&apos; is not referenced later in this execution path and has a retain count of +2</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;date&apos; is not referenced later in this execution path and has a retain count of +2</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;date&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>2a319c210c1c5b4274e3f28931ead03b</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f7</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>418</integer>
+   <key>line</key><integer>425</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>414</integer>
-    <integer>415</integer>
-    <integer>416</integer>
-    <integer>417</integer>
-    <integer>418</integer>
+    <integer>421</integer>
+    <integer>422</integer>
+    <integer>423</integer>
+    <integer>424</integer>
+    <integer>425</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>415</integer>
+           <key>line</key><integer>422</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>415</integer>
+           <key>line</key><integer>422</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>417</integer>
+           <key>line</key><integer>424</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>417</integer>
+           <key>line</key><integer>424</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>417</integer>
+      <key>line</key><integer>424</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>417</integer>
+         <key>line</key><integer>424</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>417</integer>
+         <key>line</key><integer>424</integer>
          <key>col</key><integer>52</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>417</integer>
+           <key>line</key><integer>424</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>417</integer>
+           <key>line</key><integer>424</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>418</integer>
+           <key>line</key><integer>425</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>418</integer>
+           <key>line</key><integer>425</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>418</integer>
+      <key>line</key><integer>425</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>418</integer>
+         <key>line</key><integer>425</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>418</integer>
+         <key>line</key><integer>425</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;date&apos; is returned from a function whose name (&apos;f7&apos;) does not contain &apos;Copy&apos; or &apos;Create&apos;.  This violates the naming convention rules given in the Memory Management Guide for Core Foundation</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;date&apos; is returned from a function whose name (&apos;f7&apos;) does not contain &apos;Copy&apos; or &apos;Create&apos;.  This violates the naming convention rules given in the Memory Management Guide for Core Foundation</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;date&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak of returned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>2c347e0a0af508867a6d854a3fc8f690</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f7</string>
   <key>issue_hash_function_offset</key><string>3</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>418</integer>
+   <key>line</key><integer>425</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>414</integer>
-    <integer>415</integer>
-    <integer>416</integer>
-    <integer>417</integer>
-    <integer>418</integer>
+    <integer>421</integer>
+    <integer>422</integer>
+    <integer>423</integer>
+    <integer>424</integer>
+    <integer>425</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>426</integer>
+      <key>line</key><integer>433</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>426</integer>
+         <key>line</key><integer>433</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>426</integer>
+         <key>line</key><integer>433</integer>
          <key>col</key><integer>33</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;MyDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;MyDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>426</integer>
+           <key>line</key><integer>433</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>426</integer>
+           <key>line</key><integer>433</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>427</integer>
+           <key>line</key><integer>434</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>427</integer>
+           <key>line</key><integer>434</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>427</integer>
+      <key>line</key><integer>434</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>427</integer>
+         <key>line</key><integer>434</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>427</integer>
+         <key>line</key><integer>434</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>427</integer>
+         <key>line</key><integer>434</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>427</integer>
+         <key>line</key><integer>434</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +2 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +2 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>427</integer>
+           <key>line</key><integer>434</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>427</integer>
+           <key>line</key><integer>434</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>428</integer>
+           <key>line</key><integer>435</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>428</integer>
+           <key>line</key><integer>435</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>428</integer>
+      <key>line</key><integer>435</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>428</integer>
+         <key>line</key><integer>435</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>428</integer>
+         <key>line</key><integer>435</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;date&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;date&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;date&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>0be746eb38e868156f7f57ea95735f4e</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f8</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>428</integer>
+   <key>line</key><integer>435</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>425</integer>
-    <integer>426</integer>
-    <integer>427</integer>
-    <integer>428</integer>
+    <integer>432</integer>
+    <integer>433</integer>
+    <integer>434</integer>
+    <integer>435</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>432</integer>
+           <key>line</key><integer>439</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>432</integer>
+           <key>line</key><integer>439</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>433</integer>
+           <key>line</key><integer>440</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>433</integer>
+           <key>line</key><integer>440</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>433</integer>
+      <key>line</key><integer>440</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>433</integer>
+         <key>line</key><integer>440</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>433</integer>
+         <key>line</key><integer>440</integer>
          <key>col</key><integer>8</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>&apos;p&apos; initialized to a null pointer value</string>
      <key>message</key>
      <string>&apos;p&apos; initialized to a null pointer value</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>433</integer>
+           <key>line</key><integer>440</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>433</integer>
+           <key>line</key><integer>440</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>435</integer>
+      <key>line</key><integer>442</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>435</integer>
+         <key>line</key><integer>442</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>435</integer>
+         <key>line</key><integer>442</integer>
          <key>col</key><integer>11</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;date&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;date&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>435</integer>
+           <key>line</key><integer>442</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>435</integer>
+      <key>line</key><integer>442</integer>
       <key>col</key><integer>17</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>435</integer>
+         <key>line</key><integer>442</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>435</integer>
+         <key>line</key><integer>442</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
      <key>message</key>
      <string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
     </dict>
    </array>
    <key>description</key><string>Dereference of null pointer (loaded from variable &apos;p&apos;)</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>4af5d8d1438976cc7fa006af5f843b13</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f9</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>435</integer>
+   <key>line</key><integer>442</integer>
    <key>col</key><integer>17</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>431</integer>
-    <integer>432</integer>
-    <integer>433</integer>
-    <integer>435</integer>
+    <integer>438</integer>
+    <integer>439</integer>
+    <integer>440</integer>
+    <integer>442</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>444</integer>
+      <key>line</key><integer>451</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>444</integer>
+         <key>line</key><integer>451</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>444</integer>
+         <key>line</key><integer>451</integer>
          <key>col</key><integer>75</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;DADiskCreateFromBSDName&apos; returns a Core Foundation object of type &apos;DADiskRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;DADiskCreateFromBSDName&apos; returns a Core Foundation object of type &apos;DADiskRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>444</integer>
+           <key>line</key><integer>451</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>444</integer>
+           <key>line</key><integer>451</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>445</integer>
+      <key>line</key><integer>452</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>445</integer>
+         <key>line</key><integer>452</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>445</integer>
+         <key>line</key><integer>452</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is non-null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is non-null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>448</integer>
+      <key>line</key><integer>455</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>448</integer>
+         <key>line</key><integer>455</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>448</integer>
+         <key>line</key><integer>455</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>26</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>46</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>450</integer>
+      <key>line</key><integer>457</integer>
       <key>col</key><integer>26</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>450</integer>
+         <key>line</key><integer>457</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>450</integer>
+         <key>line</key><integer>457</integer>
          <key>col</key><integer>46</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;disk&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;disk&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;disk&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>3e83186b5b944ef7a3ec026d469d5ad7</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f10</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>450</integer>
+   <key>line</key><integer>457</integer>
    <key>col</key><integer>26</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>443</integer>
-    <integer>444</integer>
-    <integer>445</integer>
-    <integer>447</integer>
-    <integer>448</integer>
     <integer>450</integer>
+    <integer>451</integer>
+    <integer>452</integer>
+    <integer>454</integer>
+    <integer>455</integer>
+    <integer>457</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>444</integer>
+           <key>line</key><integer>451</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>444</integer>
+           <key>line</key><integer>451</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>445</integer>
+      <key>line</key><integer>452</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>445</integer>
+         <key>line</key><integer>452</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>445</integer>
+         <key>line</key><integer>452</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>448</integer>
+      <key>line</key><integer>455</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>448</integer>
+         <key>line</key><integer>455</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>448</integer>
+         <key>line</key><integer>455</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>450</integer>
+      <key>line</key><integer>457</integer>
       <key>col</key><integer>26</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>450</integer>
+         <key>line</key><integer>457</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>450</integer>
+         <key>line</key><integer>457</integer>
          <key>col</key><integer>49</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;DADiskCopyDescription&apos; returns a Core Foundation object of type &apos;CFDictionaryRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;DADiskCopyDescription&apos; returns a Core Foundation object of type &apos;CFDictionaryRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>451</integer>
+      <key>line</key><integer>458</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>451</integer>
+         <key>line</key><integer>458</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>451</integer>
+         <key>line</key><integer>458</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;dict&apos; is non-null</string>
      <key>message</key>
      <string>Assuming &apos;dict&apos; is non-null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>451</integer>
+      <key>line</key><integer>458</integer>
       <key>col</key><integer>13</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>451</integer>
+         <key>line</key><integer>458</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>451</integer>
+         <key>line</key><integer>458</integer>
          <key>col</key><integer>17</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;dict&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;dict&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;dict&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>ffc6479dc21fc10cdb83b4392685ed36</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f10</string>
   <key>issue_hash_function_offset</key><string>7</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>451</integer>
+   <key>line</key><integer>458</integer>
    <key>col</key><integer>13</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>443</integer>
-    <integer>444</integer>
-    <integer>445</integer>
-    <integer>447</integer>
-    <integer>448</integer>
     <integer>450</integer>
     <integer>451</integer>
+    <integer>452</integer>
+    <integer>454</integer>
+    <integer>455</integer>
+    <integer>457</integer>
+    <integer>458</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>444</integer>
+           <key>line</key><integer>451</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>444</integer>
+           <key>line</key><integer>451</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>445</integer>
+      <key>line</key><integer>452</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>445</integer>
+         <key>line</key><integer>452</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>445</integer>
+         <key>line</key><integer>452</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>448</integer>
+      <key>line</key><integer>455</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>448</integer>
+         <key>line</key><integer>455</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>448</integer>
+         <key>line</key><integer>455</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>451</integer>
+      <key>line</key><integer>458</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>451</integer>
+         <key>line</key><integer>458</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>451</integer>
+         <key>line</key><integer>458</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;dict&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;dict&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>453</integer>
+      <key>line</key><integer>460</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>453</integer>
+         <key>line</key><integer>460</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>453</integer>
+         <key>line</key><integer>460</integer>
          <key>col</key><integer>31</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;DADiskCopyWholeDisk&apos; returns a Core Foundation object of type &apos;DADiskRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;DADiskCopyWholeDisk&apos; returns a Core Foundation object of type &apos;DADiskRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>454</integer>
+      <key>line</key><integer>461</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>454</integer>
+         <key>line</key><integer>461</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>454</integer>
+         <key>line</key><integer>461</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is non-null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is non-null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>454</integer>
+      <key>line</key><integer>461</integer>
       <key>col</key><integer>13</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>454</integer>
+         <key>line</key><integer>461</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>454</integer>
+         <key>line</key><integer>461</integer>
          <key>col</key><integer>17</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;disk&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;disk&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;disk&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>1c06fc99a1d078653ae8e4fe308e09cd</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f10</string>
   <key>issue_hash_function_offset</key><string>10</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>454</integer>
+   <key>line</key><integer>461</integer>
    <key>col</key><integer>13</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>443</integer>
-    <integer>444</integer>
-    <integer>445</integer>
-    <integer>447</integer>
-    <integer>448</integer>
     <integer>450</integer>
     <integer>451</integer>
-    <integer>453</integer>
+    <integer>452</integer>
     <integer>454</integer>
+    <integer>455</integer>
+    <integer>457</integer>
+    <integer>458</integer>
+    <integer>460</integer>
+    <integer>461</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>444</integer>
+           <key>line</key><integer>451</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>444</integer>
+           <key>line</key><integer>451</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>445</integer>
+      <key>line</key><integer>452</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>445</integer>
+         <key>line</key><integer>452</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>445</integer>
+         <key>line</key><integer>452</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>447</integer>
+      <key>line</key><integer>454</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>447</integer>
+         <key>line</key><integer>454</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>447</integer>
+         <key>line</key><integer>454</integer>
          <key>col</key><integer>63</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;DADiskCreateFromIOMedia&apos; returns a Core Foundation object of type &apos;DADiskRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;DADiskCreateFromIOMedia&apos; returns a Core Foundation object of type &apos;DADiskRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>448</integer>
+      <key>line</key><integer>455</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>448</integer>
+         <key>line</key><integer>455</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>448</integer>
+         <key>line</key><integer>455</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is non-null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is non-null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>451</integer>
+      <key>line</key><integer>458</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>451</integer>
+         <key>line</key><integer>458</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>451</integer>
+         <key>line</key><integer>458</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;dict&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;dict&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>454</integer>
+      <key>line</key><integer>461</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>454</integer>
+         <key>line</key><integer>461</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>454</integer>
+         <key>line</key><integer>461</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>46</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>456</integer>
+      <key>line</key><integer>463</integer>
       <key>col</key><integer>30</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>456</integer>
+         <key>line</key><integer>463</integer>
          <key>col</key><integer>30</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>456</integer>
+         <key>line</key><integer>463</integer>
          <key>col</key><integer>46</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;disk&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;disk&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;disk&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>460f099c6ae21a4b3ae818c9f65df2b0</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f10</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>456</integer>
+   <key>line</key><integer>463</integer>
    <key>col</key><integer>30</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>443</integer>
-    <integer>444</integer>
-    <integer>445</integer>
-    <integer>447</integer>
-    <integer>448</integer>
     <integer>450</integer>
     <integer>451</integer>
-    <integer>453</integer>
+    <integer>452</integer>
     <integer>454</integer>
-    <integer>456</integer>
+    <integer>455</integer>
+    <integer>457</integer>
+    <integer>458</integer>
+    <integer>460</integer>
+    <integer>461</integer>
+    <integer>463</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>444</integer>
+           <key>line</key><integer>451</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>444</integer>
+           <key>line</key><integer>451</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>445</integer>
+      <key>line</key><integer>452</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>445</integer>
+         <key>line</key><integer>452</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>445</integer>
+         <key>line</key><integer>452</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>448</integer>
+      <key>line</key><integer>455</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>448</integer>
+         <key>line</key><integer>455</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>448</integer>
+         <key>line</key><integer>455</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>451</integer>
+      <key>line</key><integer>458</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>451</integer>
+         <key>line</key><integer>458</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>451</integer>
+         <key>line</key><integer>458</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;dict&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;dict&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>454</integer>
+      <key>line</key><integer>461</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>454</integer>
+         <key>line</key><integer>461</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>454</integer>
+         <key>line</key><integer>461</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>46</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>456</integer>
+      <key>line</key><integer>463</integer>
       <key>col</key><integer>30</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>456</integer>
+         <key>line</key><integer>463</integer>
          <key>col</key><integer>30</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>457</integer>
+         <key>line</key><integer>464</integer>
          <key>col</key><integer>68</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;DADissenterCreate&apos; returns a Core Foundation object of type &apos;DADissenterRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;DADissenterCreate&apos; returns a Core Foundation object of type &apos;DADissenterRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>46</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>458</integer>
+      <key>line</key><integer>465</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>458</integer>
+         <key>line</key><integer>465</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>458</integer>
+         <key>line</key><integer>465</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;dissenter&apos; is non-null</string>
      <key>message</key>
      <string>Assuming &apos;dissenter&apos; is non-null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>18</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>22</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>458</integer>
+      <key>line</key><integer>465</integer>
       <key>col</key><integer>18</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>458</integer>
+         <key>line</key><integer>465</integer>
          <key>col</key><integer>18</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>458</integer>
+         <key>line</key><integer>465</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;dissenter&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;dissenter&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;dissenter&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>65004e269b1b5cb5d9b5c6f7a02926e3</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f10</string>
   <key>issue_hash_function_offset</key><string>13</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>458</integer>
+   <key>line</key><integer>465</integer>
    <key>col</key><integer>18</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>443</integer>
-    <integer>444</integer>
-    <integer>445</integer>
-    <integer>447</integer>
-    <integer>448</integer>
     <integer>450</integer>
     <integer>451</integer>
-    <integer>453</integer>
+    <integer>452</integer>
     <integer>454</integer>
-    <integer>456</integer>
+    <integer>455</integer>
     <integer>457</integer>
     <integer>458</integer>
+    <integer>460</integer>
+    <integer>461</integer>
+    <integer>463</integer>
+    <integer>464</integer>
+    <integer>465</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>444</integer>
+           <key>line</key><integer>451</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>444</integer>
+           <key>line</key><integer>451</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>445</integer>
+      <key>line</key><integer>452</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>445</integer>
+         <key>line</key><integer>452</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>445</integer>
+         <key>line</key><integer>452</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>445</integer>
+           <key>line</key><integer>452</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>447</integer>
+           <key>line</key><integer>454</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>448</integer>
+      <key>line</key><integer>455</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>448</integer>
+         <key>line</key><integer>455</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>448</integer>
+         <key>line</key><integer>455</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>448</integer>
+           <key>line</key><integer>455</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>450</integer>
+           <key>line</key><integer>457</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>451</integer>
+      <key>line</key><integer>458</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>451</integer>
+         <key>line</key><integer>458</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>451</integer>
+         <key>line</key><integer>458</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;dict&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;dict&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>451</integer>
+           <key>line</key><integer>458</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>453</integer>
+           <key>line</key><integer>460</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>454</integer>
+      <key>line</key><integer>461</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>454</integer>
+         <key>line</key><integer>461</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>454</integer>
+         <key>line</key><integer>461</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;disk&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;disk&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>454</integer>
+           <key>line</key><integer>461</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>456</integer>
+           <key>line</key><integer>463</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>458</integer>
+      <key>line</key><integer>465</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>458</integer>
+         <key>line</key><integer>465</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>458</integer>
+         <key>line</key><integer>465</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;dissenter&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;dissenter&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>458</integer>
+           <key>line</key><integer>465</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>460</integer>
+           <key>line</key><integer>467</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>460</integer>
+           <key>line</key><integer>467</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>460</integer>
+      <key>line</key><integer>467</integer>
       <key>col</key><integer>26</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>460</integer>
+         <key>line</key><integer>467</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>460</integer>
+         <key>line</key><integer>467</integer>
          <key>col</key><integer>61</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;DASessionCreate&apos; returns a Core Foundation object of type &apos;DASessionRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;DASessionCreate&apos; returns a Core Foundation object of type &apos;DASessionRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>460</integer>
+           <key>line</key><integer>467</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>460</integer>
+           <key>line</key><integer>467</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>461</integer>
+           <key>line</key><integer>468</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>461</integer>
+           <key>line</key><integer>468</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>461</integer>
+           <key>line</key><integer>468</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>461</integer>
+           <key>line</key><integer>468</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>461</integer>
+           <key>line</key><integer>468</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>461</integer>
+           <key>line</key><integer>468</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>461</integer>
+      <key>line</key><integer>468</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>461</integer>
+         <key>line</key><integer>468</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>461</integer>
+         <key>line</key><integer>468</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;session&apos; is non-null</string>
      <key>message</key>
      <string>Assuming &apos;session&apos; is non-null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>461</integer>
+           <key>line</key><integer>468</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>461</integer>
+           <key>line</key><integer>468</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>461</integer>
+           <key>line</key><integer>468</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>461</integer>
+           <key>line</key><integer>468</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>461</integer>
+      <key>line</key><integer>468</integer>
       <key>col</key><integer>16</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>461</integer>
+         <key>line</key><integer>468</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>461</integer>
+         <key>line</key><integer>468</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;session&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;session&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;session&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>e9c1be038ef498b7985f5b1ddcb5444f</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f10</string>
   <key>issue_hash_function_offset</key><string>17</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>461</integer>
+   <key>line</key><integer>468</integer>
    <key>col</key><integer>16</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>443</integer>
-    <integer>444</integer>
-    <integer>445</integer>
-    <integer>447</integer>
-    <integer>448</integer>
     <integer>450</integer>
     <integer>451</integer>
-    <integer>453</integer>
+    <integer>452</integer>
     <integer>454</integer>
-    <integer>456</integer>
+    <integer>455</integer>
     <integer>457</integer>
     <integer>458</integer>
     <integer>460</integer>
     <integer>461</integer>
+    <integer>463</integer>
+    <integer>464</integer>
+    <integer>465</integer>
+    <integer>467</integer>
+    <integer>468</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>478</integer>
+      <key>line</key><integer>485</integer>
       <key>col</key><integer>16</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>478</integer>
+         <key>line</key><integer>485</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>478</integer>
+         <key>line</key><integer>485</integer>
          <key>col</key><integer>31</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CMCreateFooRef&apos; returns a Core Foundation object of type &apos;CMFooRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CMCreateFooRef&apos; returns a Core Foundation object of type &apos;CMFooRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>478</integer>
+           <key>line</key><integer>485</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>478</integer>
+           <key>line</key><integer>485</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>479</integer>
+           <key>line</key><integer>486</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>479</integer>
+           <key>line</key><integer>486</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>479</integer>
+      <key>line</key><integer>486</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;f&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;f&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;f&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>9c7c3b2bf298c7d046fd6fc7f6fe688e</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testLeakCoreMediaReferenceType</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>479</integer>
+   <key>line</key><integer>486</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>477</integer>
-    <integer>478</integer>
-    <integer>479</integer>
+    <integer>484</integer>
+    <integer>485</integer>
+    <integer>486</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>482</integer>
+      <key>line</key><integer>489</integer>
       <key>col</key><integer>16</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>482</integer>
+         <key>line</key><integer>489</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>482</integer>
+         <key>line</key><integer>489</integer>
          <key>col</key><integer>28</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CMGetFooRef&apos; returns a Core Foundation object of type &apos;CMFooRef&apos; with a +0 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CMGetFooRef&apos; returns a Core Foundation object of type &apos;CMFooRef&apos; with a +0 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>482</integer>
+           <key>line</key><integer>489</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>482</integer>
+           <key>line</key><integer>489</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>483</integer>
+           <key>line</key><integer>490</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>483</integer>
+           <key>line</key><integer>490</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>483</integer>
+      <key>line</key><integer>490</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>483</integer>
+         <key>line</key><integer>490</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>483</integer>
+         <key>line</key><integer>490</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Incorrect decrement of the reference count of an object that is not owned at this point by the caller</string>
      <key>message</key>
      <string>Incorrect decrement of the reference count of an object that is not owned at this point by the caller</string>
     </dict>
    </array>
    <key>description</key><string>Incorrect decrement of the reference count of an object that is not owned at this point by the caller</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Bad release</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>69932084739a429d667d8de6de42af0b</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testOverReleaseMediaReferenceType</string>
   <key>issue_hash_function_offset</key><string>2</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>483</integer>
+   <key>line</key><integer>490</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>481</integer>
-    <integer>482</integer>
-    <integer>483</integer>
+    <integer>488</integer>
+    <integer>489</integer>
+    <integer>490</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>516</integer>
+           <key>line</key><integer>523</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>516</integer>
+           <key>line</key><integer>523</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>520</integer>
+           <key>line</key><integer>527</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>520</integer>
+           <key>line</key><integer>527</integer>
            <key>col</key><integer>21</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>520</integer>
+      <key>line</key><integer>527</integer>
       <key>col</key><integer>23</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>520</integer>
+         <key>line</key><integer>527</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>520</integer>
+         <key>line</key><integer>527</integer>
          <key>col</key><integer>57</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;buffer&apos; is not equal to &apos;queue&apos;</string>
      <key>message</key>
      <string>Assuming &apos;buffer&apos; is not equal to &apos;queue&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>520</integer>
+      <key>line</key><integer>527</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>520</integer>
+         <key>line</key><integer>527</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>520</integer>
+         <key>line</key><integer>527</integer>
          <key>col</key><integer>58</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>FALSE</string>
      <key>message</key>
      <string>FALSE</string>
     </dict>
    </array>
    <key>description</key><string>FALSE</string>
    <key>category</key><string>debug</string>
    <key>type</key><string>Checking analyzer assumptions</string>
    <key>check_name</key><string>debug.ExprInspection</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>78b71dc497a2059b950406cb2a1cfd01</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testCMBufferQueueDequeueAndRetain</string>
   <key>issue_hash_function_offset</key><string>5</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>520</integer>
+   <key>line</key><integer>527</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>515</integer>
-    <integer>516</integer>
-    <integer>520</integer>
+    <integer>522</integer>
+    <integer>523</integer>
+    <integer>527</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>516</integer>
+           <key>line</key><integer>523</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>516</integer>
+           <key>line</key><integer>523</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>520</integer>
+           <key>line</key><integer>527</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>520</integer>
+           <key>line</key><integer>527</integer>
            <key>col</key><integer>21</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>520</integer>
+      <key>line</key><integer>527</integer>
       <key>col</key><integer>23</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>520</integer>
+         <key>line</key><integer>527</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>520</integer>
+         <key>line</key><integer>527</integer>
          <key>col</key><integer>57</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;buffer&apos; is equal to &apos;queue&apos;</string>
      <key>message</key>
      <string>Assuming &apos;buffer&apos; is equal to &apos;queue&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>520</integer>
+      <key>line</key><integer>527</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>520</integer>
+         <key>line</key><integer>527</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>520</integer>
+         <key>line</key><integer>527</integer>
          <key>col</key><integer>58</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>TRUE</string>
      <key>message</key>
      <string>TRUE</string>
     </dict>
    </array>
    <key>description</key><string>TRUE</string>
    <key>category</key><string>debug</string>
    <key>type</key><string>Checking analyzer assumptions</string>
    <key>check_name</key><string>debug.ExprInspection</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>78b71dc497a2059b950406cb2a1cfd01</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testCMBufferQueueDequeueAndRetain</string>
   <key>issue_hash_function_offset</key><string>5</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>520</integer>
+   <key>line</key><integer>527</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>515</integer>
-    <integer>516</integer>
-    <integer>520</integer>
+    <integer>522</integer>
+    <integer>523</integer>
+    <integer>527</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>516</integer>
+      <key>line</key><integer>523</integer>
       <key>col</key><integer>24</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>516</integer>
+         <key>line</key><integer>523</integer>
          <key>col</key><integer>24</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>516</integer>
+         <key>line</key><integer>523</integer>
          <key>col</key><integer>59</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CMBufferQueueDequeueAndRetain&apos; returns a Core Foundation object of type &apos;CMBufferRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CMBufferQueueDequeueAndRetain&apos; returns a Core Foundation object of type &apos;CMBufferRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>516</integer>
+           <key>line</key><integer>523</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>516</integer>
+           <key>line</key><integer>523</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>520</integer>
+           <key>line</key><integer>527</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>520</integer>
+           <key>line</key><integer>527</integer>
            <key>col</key><integer>21</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>520</integer>
+      <key>line</key><integer>527</integer>
       <key>col</key><integer>23</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>520</integer>
+         <key>line</key><integer>527</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>520</integer>
+         <key>line</key><integer>527</integer>
          <key>col</key><integer>57</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;buffer&apos; is not equal to &apos;queue&apos;</string>
      <key>message</key>
      <string>Assuming &apos;buffer&apos; is not equal to &apos;queue&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>520</integer>
+      <key>line</key><integer>527</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>520</integer>
+         <key>line</key><integer>527</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>520</integer>
+         <key>line</key><integer>527</integer>
          <key>col</key><integer>58</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;buffer&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;buffer&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;buffer&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>0f30258c45ed9ecd8646db90eaf20c4a</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testCMBufferQueueDequeueAndRetain</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>520</integer>
+   <key>line</key><integer>527</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>515</integer>
-    <integer>516</integer>
-    <integer>520</integer>
+    <integer>522</integer>
+    <integer>523</integer>
+    <integer>527</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>527</integer>
+           <key>line</key><integer>534</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>527</integer>
+           <key>line</key><integer>534</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>540</integer>
+           <key>line</key><integer>547</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>540</integer>
+           <key>line</key><integer>547</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>540</integer>
+      <key>line</key><integer>547</integer>
       <key>col</key><integer>22</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>540</integer>
+         <key>line</key><integer>547</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>540</integer>
+         <key>line</key><integer>547</integer>
          <key>col</key><integer>49</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFArrayGetValueAtIndex&apos; returns a Core Foundation object of type &apos;const void *&apos; with a +0 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFArrayGetValueAtIndex&apos; returns a Core Foundation object of type &apos;const void *&apos; with a +0 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>540</integer>
+           <key>line</key><integer>547</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>540</integer>
+           <key>line</key><integer>547</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>546</integer>
+           <key>line</key><integer>553</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>546</integer>
+           <key>line</key><integer>553</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>546</integer>
+      <key>line</key><integer>553</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>546</integer>
+         <key>line</key><integer>553</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>546</integer>
+         <key>line</key><integer>553</integer>
          <key>col</key><integer>14</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Incorrect decrement of the reference count of an object that is not owned at this point by the caller</string>
      <key>message</key>
      <string>Incorrect decrement of the reference count of an object that is not owned at this point by the caller</string>
     </dict>
    </array>
    <key>description</key><string>Incorrect decrement of the reference count of an object that is not owned at this point by the caller</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Bad release</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>13e672795c0e57433c642c84f26f6c9b</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f11</string>
   <key>issue_hash_function_offset</key><string>21</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>546</integer>
+   <key>line</key><integer>553</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>525</integer>
-    <integer>527</integer>
-    <integer>530</integer>
-    <integer>531</integer>
+    <integer>532</integer>
     <integer>534</integer>
     <integer>537</integer>
-    <integer>540</integer>
-    <integer>543</integer>
-    <integer>546</integer>
+    <integer>538</integer>
+    <integer>541</integer>
+    <integer>544</integer>
+    <integer>547</integer>
+    <integer>550</integer>
+    <integer>553</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>554</integer>
+      <key>line</key><integer>561</integer>
       <key>col</key><integer>17</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>554</integer>
+         <key>line</key><integer>561</integer>
          <key>col</key><integer>17</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>554</integer>
+         <key>line</key><integer>561</integer>
          <key>col</key><integer>29</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;MyCreateFun&apos; returns a Core Foundation object of type &apos;CFTypeRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;MyCreateFun&apos; returns a Core Foundation object of type &apos;CFTypeRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>554</integer>
+           <key>line</key><integer>561</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>554</integer>
+           <key>line</key><integer>561</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>555</integer>
+           <key>line</key><integer>562</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>555</integer>
+           <key>line</key><integer>562</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>555</integer>
+      <key>line</key><integer>562</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;o&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;o&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;o&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>eeff9e133573bdbc1aeb633284cbdb2b</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f12</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>555</integer>
+   <key>line</key><integer>562</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>553</integer>
-    <integer>554</integer>
-    <integer>555</integer>
+    <integer>560</integer>
+    <integer>561</integer>
+    <integer>562</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>563</integer>
+      <key>line</key><integer>570</integer>
       <key>col</key><integer>25</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>563</integer>
+         <key>line</key><integer>570</integer>
          <key>col</key><integer>25</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>563</integer>
+         <key>line</key><integer>570</integer>
          <key>col</key><integer>75</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>563</integer>
+           <key>line</key><integer>570</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>563</integer>
+           <key>line</key><integer>570</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>564</integer>
+           <key>line</key><integer>571</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>564</integer>
+           <key>line</key><integer>571</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>564</integer>
+      <key>line</key><integer>571</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>564</integer>
+         <key>line</key><integer>571</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>564</integer>
+         <key>line</key><integer>571</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>564</integer>
+         <key>line</key><integer>571</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>564</integer>
+         <key>line</key><integer>571</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object autoreleased</string>
      <key>message</key>
      <string>Object autoreleased</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>564</integer>
+           <key>line</key><integer>571</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>564</integer>
+           <key>line</key><integer>571</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>565</integer>
+           <key>line</key><integer>572</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>565</integer>
+           <key>line</key><integer>572</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>565</integer>
+      <key>line</key><integer>572</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>565</integer>
+         <key>line</key><integer>572</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>565</integer>
+         <key>line</key><integer>572</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>565</integer>
+         <key>line</key><integer>572</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>565</integer>
+         <key>line</key><integer>572</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object autoreleased</string>
      <key>message</key>
      <string>Object autoreleased</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>565</integer>
+           <key>line</key><integer>572</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>565</integer>
+           <key>line</key><integer>572</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>566</integer>
+           <key>line</key><integer>573</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>566</integer>
+           <key>line</key><integer>573</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>566</integer>
+      <key>line</key><integer>573</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object was autoreleased 2 times but the object has a +1 retain count</string>
      <key>message</key>
      <string>Object was autoreleased 2 times but the object has a +1 retain count</string>
     </dict>
    </array>
    <key>description</key><string>Object autoreleased too many times</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Object autoreleased too many times</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>620a4245edc8df18036da34702ca01c8</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f13_autorelease_b</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>566</integer>
+   <key>line</key><integer>573</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>562</integer>
-    <integer>563</integer>
-    <integer>564</integer>
-    <integer>565</integer>
-    <integer>566</integer>
+    <integer>569</integer>
+    <integer>570</integer>
+    <integer>571</integer>
+    <integer>572</integer>
+    <integer>573</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>569</integer>
+      <key>line</key><integer>576</integer>
       <key>col</key><integer>25</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>569</integer>
+         <key>line</key><integer>576</integer>
          <key>col</key><integer>25</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>569</integer>
+         <key>line</key><integer>576</integer>
          <key>col</key><integer>75</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>569</integer>
+           <key>line</key><integer>576</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>569</integer>
+           <key>line</key><integer>576</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>570</integer>
+           <key>line</key><integer>577</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>570</integer>
+           <key>line</key><integer>577</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>570</integer>
+      <key>line</key><integer>577</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>570</integer>
+         <key>line</key><integer>577</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>570</integer>
+         <key>line</key><integer>577</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>570</integer>
+         <key>line</key><integer>577</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>570</integer>
+         <key>line</key><integer>577</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object autoreleased</string>
      <key>message</key>
      <string>Object autoreleased</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>570</integer>
+           <key>line</key><integer>577</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>570</integer>
+           <key>line</key><integer>577</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>571</integer>
+           <key>line</key><integer>578</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>571</integer>
+           <key>line</key><integer>578</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>571</integer>
+      <key>line</key><integer>578</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>571</integer>
+         <key>line</key><integer>578</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>571</integer>
+         <key>line</key><integer>578</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>571</integer>
+         <key>line</key><integer>578</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>571</integer>
+         <key>line</key><integer>578</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object autoreleased</string>
      <key>message</key>
      <string>Object autoreleased</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>571</integer>
+           <key>line</key><integer>578</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>571</integer>
+           <key>line</key><integer>578</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>572</integer>
+           <key>line</key><integer>579</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>572</integer>
+           <key>line</key><integer>579</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>572</integer>
+      <key>line</key><integer>579</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>572</integer>
+         <key>line</key><integer>579</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>572</integer>
+         <key>line</key><integer>579</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object was autoreleased 2 times but the object has a +0 retain count</string>
      <key>message</key>
      <string>Object was autoreleased 2 times but the object has a +0 retain count</string>
     </dict>
    </array>
    <key>description</key><string>Object autoreleased too many times</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Object autoreleased too many times</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>1a87a5f904c165069a731b0325d45edf</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f13_autorelease_c</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>572</integer>
+   <key>line</key><integer>579</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>568</integer>
-    <integer>569</integer>
-    <integer>570</integer>
-    <integer>571</integer>
-    <integer>572</integer>
+    <integer>575</integer>
+    <integer>576</integer>
+    <integer>577</integer>
+    <integer>578</integer>
+    <integer>579</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>576</integer>
+      <key>line</key><integer>583</integer>
       <key>col</key><integer>25</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>576</integer>
+         <key>line</key><integer>583</integer>
          <key>col</key><integer>25</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>576</integer>
+         <key>line</key><integer>583</integer>
          <key>col</key><integer>75</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>576</integer>
+           <key>line</key><integer>583</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>576</integer>
+           <key>line</key><integer>583</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>577</integer>
+           <key>line</key><integer>584</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>577</integer>
+           <key>line</key><integer>584</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>577</integer>
+      <key>line</key><integer>584</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>577</integer>
+         <key>line</key><integer>584</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>577</integer>
+         <key>line</key><integer>584</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>577</integer>
+         <key>line</key><integer>584</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>577</integer>
+         <key>line</key><integer>584</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object autoreleased</string>
      <key>message</key>
      <string>Object autoreleased</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>577</integer>
+           <key>line</key><integer>584</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>577</integer>
+           <key>line</key><integer>584</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>578</integer>
+           <key>line</key><integer>585</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>578</integer>
+           <key>line</key><integer>585</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>578</integer>
+      <key>line</key><integer>585</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>578</integer>
+         <key>line</key><integer>585</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>578</integer>
+         <key>line</key><integer>585</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>578</integer>
+         <key>line</key><integer>585</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>578</integer>
+         <key>line</key><integer>585</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object autoreleased</string>
      <key>message</key>
      <string>Object autoreleased</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>578</integer>
+           <key>line</key><integer>585</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>578</integer>
+           <key>line</key><integer>585</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>579</integer>
+           <key>line</key><integer>586</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>579</integer>
+           <key>line</key><integer>586</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>579</integer>
+           <key>line</key><integer>586</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>579</integer>
+           <key>line</key><integer>586</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>579</integer>
+           <key>line</key><integer>586</integer>
            <key>col</key><integer>25</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>579</integer>
+           <key>line</key><integer>586</integer>
            <key>col</key><integer>44</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>579</integer>
+      <key>line</key><integer>586</integer>
       <key>col</key><integer>25</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>579</integer>
+         <key>line</key><integer>586</integer>
          <key>col</key><integer>25</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>579</integer>
+         <key>line</key><integer>586</integer>
          <key>col</key><integer>75</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object was autoreleased 2 times but the object has a +1 retain count</string>
      <key>message</key>
      <string>Object was autoreleased 2 times but the object has a +1 retain count</string>
     </dict>
    </array>
    <key>description</key><string>Object autoreleased too many times</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Object autoreleased too many times</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>6ed645efdfe968f31d4356610bb6dd02</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f13_autorelease_d</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>579</integer>
+   <key>line</key><integer>586</integer>
    <key>col</key><integer>25</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>575</integer>
-    <integer>576</integer>
-    <integer>577</integer>
-    <integer>578</integer>
-    <integer>579</integer>
+    <integer>582</integer>
+    <integer>583</integer>
+    <integer>584</integer>
+    <integer>585</integer>
+    <integer>586</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>587</integer>
+      <key>line</key><integer>594</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>587</integer>
+         <key>line</key><integer>594</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>587</integer>
+         <key>line</key><integer>594</integer>
          <key>col</key><integer>53</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>587</integer>
+           <key>line</key><integer>594</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>587</integer>
+           <key>line</key><integer>594</integer>
            <key>col</key><integer>22</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>588</integer>
+           <key>line</key><integer>595</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>588</integer>
+           <key>line</key><integer>595</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>588</integer>
+      <key>line</key><integer>595</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableArrayRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableArrayRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CFMutableArrayRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>5295be41524e9e28f4b1a608006801fe</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f14_leakimmediately</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>588</integer>
+   <key>line</key><integer>595</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>586</integer>
-    <integer>587</integer>
-    <integer>588</integer>
+    <integer>593</integer>
+    <integer>594</integer>
+    <integer>595</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>602</integer>
+      <key>line</key><integer>609</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>602</integer>
+         <key>line</key><integer>609</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>602</integer>
+         <key>line</key><integer>609</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;p&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;p&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>607</integer>
+           <key>line</key><integer>614</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>607</integer>
+           <key>line</key><integer>614</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>607</integer>
+      <key>line</key><integer>614</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>607</integer>
+         <key>line</key><integer>614</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>607</integer>
+         <key>line</key><integer>614</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Null pointer argument in call to CFRelease</string>
      <key>message</key>
      <string>Null pointer argument in call to CFRelease</string>
     </dict>
    </array>
    <key>description</key><string>Null pointer argument in call to CFRelease</string>
    <key>category</key><string>API Misuse (Apple)</string>
    <key>type</key><string>null passed to CF memory management function</string>
    <key>check_name</key><string>osx.coreFoundation.CFRetainRelease</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>e7e2ba205af363f2c4cec7d01dcb6d6c</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f16</string>
   <key>issue_hash_function_offset</key><string>6</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>607</integer>
+   <key>line</key><integer>614</integer>
    <key>col</key><integer>5</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>601</integer>
-    <integer>602</integer>
-    <integer>605</integer>
-    <integer>606</integer>
-    <integer>607</integer>
+    <integer>608</integer>
+    <integer>609</integer>
+    <integer>612</integer>
+    <integer>613</integer>
+    <integer>614</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>602</integer>
+      <key>line</key><integer>609</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>602</integer>
+         <key>line</key><integer>609</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>602</integer>
+         <key>line</key><integer>609</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;p&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;p&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>610</integer>
+           <key>line</key><integer>617</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>610</integer>
+           <key>line</key><integer>617</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>610</integer>
+      <key>line</key><integer>617</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>610</integer>
+         <key>line</key><integer>617</integer>
          <key>col</key><integer>14</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>610</integer>
+         <key>line</key><integer>617</integer>
          <key>col</key><integer>14</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Null pointer argument in call to CFRetain</string>
      <key>message</key>
      <string>Null pointer argument in call to CFRetain</string>
     </dict>
    </array>
    <key>description</key><string>Null pointer argument in call to CFRetain</string>
    <key>category</key><string>API Misuse (Apple)</string>
    <key>type</key><string>null passed to CF memory management function</string>
    <key>check_name</key><string>osx.coreFoundation.CFRetainRelease</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>64f4a3367d5d8e832ca8a23ca4d72717</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f16</string>
   <key>issue_hash_function_offset</key><string>9</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>610</integer>
+   <key>line</key><integer>617</integer>
    <key>col</key><integer>5</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>601</integer>
-    <integer>602</integer>
-    <integer>605</integer>
+    <integer>608</integer>
     <integer>609</integer>
-    <integer>610</integer>
+    <integer>612</integer>
+    <integer>616</integer>
+    <integer>617</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>602</integer>
+      <key>line</key><integer>609</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>602</integer>
+         <key>line</key><integer>609</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>602</integer>
+         <key>line</key><integer>609</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;p&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;p&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>613</integer>
+           <key>line</key><integer>620</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>613</integer>
+           <key>line</key><integer>620</integer>
            <key>col</key><integer>21</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>613</integer>
+      <key>line</key><integer>620</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>613</integer>
+         <key>line</key><integer>620</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>613</integer>
+         <key>line</key><integer>620</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Null pointer argument in call to CFMakeCollectable</string>
      <key>message</key>
      <string>Null pointer argument in call to CFMakeCollectable</string>
     </dict>
    </array>
    <key>description</key><string>Null pointer argument in call to CFMakeCollectable</string>
    <key>category</key><string>API Misuse (Apple)</string>
    <key>type</key><string>null passed to CF memory management function</string>
    <key>check_name</key><string>osx.coreFoundation.CFRetainRelease</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>61123dbb677396de5abbdd778c399140</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f16</string>
   <key>issue_hash_function_offset</key><string>12</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>613</integer>
+   <key>line</key><integer>620</integer>
    <key>col</key><integer>5</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>601</integer>
-    <integer>602</integer>
-    <integer>605</integer>
+    <integer>608</integer>
+    <integer>609</integer>
     <integer>612</integer>
-    <integer>613</integer>
+    <integer>619</integer>
+    <integer>620</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>602</integer>
+      <key>line</key><integer>609</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>602</integer>
+         <key>line</key><integer>609</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>602</integer>
+         <key>line</key><integer>609</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;p&apos; is null</string>
      <key>message</key>
      <string>Assuming &apos;p&apos; is null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>602</integer>
+           <key>line</key><integer>609</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>605</integer>
+           <key>line</key><integer>612</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>616</integer>
+           <key>line</key><integer>623</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>616</integer>
+           <key>line</key><integer>623</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>616</integer>
+      <key>line</key><integer>623</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>616</integer>
+         <key>line</key><integer>623</integer>
          <key>col</key><integer>19</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>616</integer>
+         <key>line</key><integer>623</integer>
          <key>col</key><integer>19</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Null pointer argument in call to CFAutorelease</string>
      <key>message</key>
      <string>Null pointer argument in call to CFAutorelease</string>
     </dict>
    </array>
    <key>description</key><string>Null pointer argument in call to CFAutorelease</string>
    <key>category</key><string>API Misuse (Apple)</string>
    <key>type</key><string>null passed to CF memory management function</string>
    <key>check_name</key><string>osx.coreFoundation.CFRetainRelease</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>965bca78fe04bfa55b6ea428da3c20e3</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f16</string>
   <key>issue_hash_function_offset</key><string>15</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>616</integer>
+   <key>line</key><integer>623</integer>
    <key>col</key><integer>5</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>601</integer>
-    <integer>602</integer>
-    <integer>605</integer>
-    <integer>615</integer>
-    <integer>616</integer>
+    <integer>608</integer>
+    <integer>609</integer>
+    <integer>612</integer>
+    <integer>622</integer>
+    <integer>623</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>656</integer>
+      <key>line</key><integer>672</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>656</integer>
+         <key>line</key><integer>672</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>656</integer>
+         <key>line</key><integer>672</integer>
          <key>col</key><integer>32</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;isl_basic_map_cow&apos; returns an object of type &apos;isl_basic_map *&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;isl_basic_map_cow&apos; returns an object of type &apos;isl_basic_map *&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>656</integer>
+           <key>line</key><integer>672</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>656</integer>
+           <key>line</key><integer>672</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>657</integer>
+           <key>line</key><integer>673</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>657</integer>
+           <key>line</key><integer>673</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>657</integer>
+      <key>line</key><integer>673</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;bmap&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;bmap&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;bmap&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>2e5affde083280f6d31ed412ac8c2396</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>f18</string>
   <key>issue_hash_function_offset</key><string>2</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>657</integer>
+   <key>line</key><integer>673</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>654</integer>
-    <integer>656</integer>
-    <integer>657</integer>
+    <integer>670</integer>
+    <integer>672</integer>
+    <integer>673</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>682</integer>
+      <key>line</key><integer>698</integer>
       <key>col</key><integer>17</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>682</integer>
+         <key>line</key><integer>698</integer>
          <key>col</key><integer>17</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>682</integer>
+         <key>line</key><integer>698</integer>
          <key>col</key><integer>55</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an Objective-C object with a +0 retain count</string>
      <key>message</key>
      <string>Method returns an Objective-C object with a +0 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>682</integer>
+           <key>line</key><integer>698</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>682</integer>
+           <key>line</key><integer>698</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>683</integer>
+           <key>line</key><integer>699</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>683</integer>
+           <key>line</key><integer>699</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>683</integer>
+      <key>line</key><integer>699</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>683</integer>
+         <key>line</key><integer>699</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>683</integer>
+         <key>line</key><integer>699</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object with a +0 retain count returned to caller where a +1 (owning) retain count is expected</string>
      <key>message</key>
      <string>Object with a +0 retain count returned to caller where a +1 (owning) retain count is expected</string>
     </dict>
    </array>
    <key>description</key><string>Object with a +0 retain count returned to caller where a +1 (owning) retain count is expected</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Method should return an owned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>fdd0cb02c08c718da2686b6e0f04aad7</string>
   <key>issue_context_kind</key><string>Objective-C method</string>
   <key>issue_context</key><string>newString</string>
   <key>issue_hash_function_offset</key><string>2</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>683</integer>
+   <key>line</key><integer>699</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>681</integer>
-    <integer>682</integer>
-    <integer>683</integer>
+    <integer>697</integer>
+    <integer>698</integer>
+    <integer>699</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>696</integer>
+      <key>line</key><integer>712</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>696</integer>
+         <key>line</key><integer>712</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>696</integer>
+         <key>line</key><integer>712</integer>
          <key>col</key><integer>63</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>696</integer>
+           <key>line</key><integer>712</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>696</integer>
+           <key>line</key><integer>712</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>703</integer>
+      <key>line</key><integer>719</integer>
       <key>col</key><integer>6</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>703</integer>
+         <key>line</key><integer>719</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>703</integer>
+         <key>line</key><integer>719</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;name&apos; is nil</string>
      <key>message</key>
      <string>Assuming &apos;name&apos; is nil</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>704</integer>
+           <key>line</key><integer>720</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>704</integer>
+           <key>line</key><integer>720</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>704</integer>
+      <key>line</key><integer>720</integer>
       <key>col</key><integer>5</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>704</integer>
+         <key>line</key><integer>720</integer>
          <key>col</key><integer>5</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>704</integer>
+         <key>line</key><integer>720</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;kind&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;kind&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;kind&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>03f39b74e1ccafa9c613ba4bb71de560</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar_6659160</string>
   <key>issue_hash_function_offset</key><string>5</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>704</integer>
+   <key>line</key><integer>720</integer>
    <key>col</key><integer>5</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>690</integer>
-    <integer>691</integer>
-    <integer>696</integer>
-    <integer>702</integer>
-    <integer>703</integer>
-    <integer>704</integer>
+    <integer>706</integer>
+    <integer>707</integer>
+    <integer>712</integer>
+    <integer>718</integer>
+    <integer>719</integer>
+    <integer>720</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>696</integer>
+           <key>line</key><integer>712</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>696</integer>
+           <key>line</key><integer>712</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>703</integer>
+      <key>line</key><integer>719</integer>
       <key>col</key><integer>6</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>703</integer>
+         <key>line</key><integer>719</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>703</integer>
+         <key>line</key><integer>719</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;name&apos; is non-nil</string>
      <key>message</key>
      <string>Assuming &apos;name&apos; is non-nil</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>706</integer>
+           <key>line</key><integer>722</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>706</integer>
+           <key>line</key><integer>722</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>706</integer>
+      <key>line</key><integer>722</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>706</integer>
+         <key>line</key><integer>722</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>706</integer>
+         <key>line</key><integer>722</integer>
          <key>col</key><integer>19</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>&apos;kindC&apos; initialized to a null pointer value</string>
      <key>message</key>
      <string>&apos;kindC&apos; initialized to a null pointer value</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>706</integer>
+           <key>line</key><integer>722</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>706</integer>
+           <key>line</key><integer>722</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>714</integer>
+      <key>line</key><integer>730</integer>
       <key>col</key><integer>6</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>714</integer>
+         <key>line</key><integer>730</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>714</integer>
+         <key>line</key><integer>730</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;kind&apos; is nil</string>
      <key>message</key>
      <string>Assuming &apos;kind&apos; is nil</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>716</integer>
+           <key>line</key><integer>732</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>716</integer>
+           <key>line</key><integer>732</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>716</integer>
+           <key>line</key><integer>732</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>716</integer>
+           <key>line</key><integer>732</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>717</integer>
+           <key>line</key><integer>733</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>717</integer>
+           <key>line</key><integer>733</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>717</integer>
+           <key>line</key><integer>733</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>717</integer>
+           <key>line</key><integer>733</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>718</integer>
+      <key>line</key><integer>734</integer>
       <key>col</key><integer>13</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>718</integer>
+         <key>line</key><integer>734</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>718</integer>
+         <key>line</key><integer>734</integer>
          <key>col</key><integer>17</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Array access (from variable &apos;kindC&apos;) results in a null pointer dereference</string>
      <key>message</key>
      <string>Array access (from variable &apos;kindC&apos;) results in a null pointer dereference</string>
     </dict>
    </array>
    <key>description</key><string>Array access (from variable &apos;kindC&apos;) results in a null pointer dereference</string>
    <key>category</key><string>Logic error</string>
    <key>type</key><string>Dereference of null pointer</string>
    <key>check_name</key><string>core.NullDereference</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>2824c4e1d4ab13c3ae5a0ebb2aa4ed89</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar_6659160</string>
   <key>issue_hash_function_offset</key><string>27</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>718</integer>
+   <key>line</key><integer>734</integer>
    <key>col</key><integer>13</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>690</integer>
-    <integer>691</integer>
-    <integer>696</integer>
-    <integer>702</integer>
-    <integer>703</integer>
     <integer>706</integer>
     <integer>707</integer>
-    <integer>714</integer>
-    <integer>716</integer>
-    <integer>717</integer>
+    <integer>712</integer>
     <integer>718</integer>
+    <integer>719</integer>
+    <integer>722</integer>
+    <integer>723</integer>
+    <integer>730</integer>
+    <integer>732</integer>
+    <integer>733</integer>
+    <integer>734</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>696</integer>
+           <key>line</key><integer>712</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>696</integer>
+           <key>line</key><integer>712</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>702</integer>
+           <key>line</key><integer>718</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>702</integer>
+           <key>line</key><integer>718</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>702</integer>
+      <key>line</key><integer>718</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>702</integer>
+         <key>line</key><integer>718</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>702</integer>
+         <key>line</key><integer>718</integer>
          <key>col</key><integer>57</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an Objective-C object with a +0 retain count</string>
      <key>message</key>
      <string>Method returns an Objective-C object with a +0 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>702</integer>
+           <key>line</key><integer>718</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>702</integer>
+           <key>line</key><integer>718</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>703</integer>
+      <key>line</key><integer>719</integer>
       <key>col</key><integer>6</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>703</integer>
+         <key>line</key><integer>719</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>703</integer>
+         <key>line</key><integer>719</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;name&apos; is non-nil</string>
      <key>message</key>
      <string>Assuming &apos;name&apos; is non-nil</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>703</integer>
+           <key>line</key><integer>719</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>706</integer>
+           <key>line</key><integer>722</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>706</integer>
+           <key>line</key><integer>722</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>706</integer>
+           <key>line</key><integer>722</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>706</integer>
+           <key>line</key><integer>722</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>714</integer>
+      <key>line</key><integer>730</integer>
       <key>col</key><integer>6</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>714</integer>
+         <key>line</key><integer>730</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>714</integer>
+         <key>line</key><integer>730</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;kind&apos; is non-nil</string>
      <key>message</key>
      <string>Assuming &apos;kind&apos; is non-nil</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>714</integer>
+           <key>line</key><integer>730</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>715</integer>
+           <key>line</key><integer>731</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>715</integer>
+           <key>line</key><integer>731</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>715</integer>
+           <key>line</key><integer>731</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>715</integer>
+           <key>line</key><integer>731</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>716</integer>
+           <key>line</key><integer>732</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>716</integer>
+           <key>line</key><integer>732</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>716</integer>
+           <key>line</key><integer>732</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>716</integer>
+           <key>line</key><integer>732</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>717</integer>
+           <key>line</key><integer>733</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>717</integer>
+           <key>line</key><integer>733</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>717</integer>
+           <key>line</key><integer>733</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>717</integer>
+           <key>line</key><integer>733</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>718</integer>
+      <key>line</key><integer>734</integer>
       <key>col</key><integer>6</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>718</integer>
+         <key>line</key><integer>734</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>718</integer>
+         <key>line</key><integer>734</integer>
          <key>col</key><integer>21</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming the condition is false</string>
      <key>message</key>
      <string>Assuming the condition is false</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>718</integer>
+           <key>line</key><integer>734</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>720</integer>
+           <key>line</key><integer>736</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>720</integer>
+           <key>line</key><integer>736</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>720</integer>
+           <key>line</key><integer>736</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>720</integer>
+           <key>line</key><integer>736</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>720</integer>
+           <key>line</key><integer>736</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>720</integer>
+           <key>line</key><integer>736</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>720</integer>
+      <key>line</key><integer>736</integer>
       <key>col</key><integer>6</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>720</integer>
+         <key>line</key><integer>736</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>720</integer>
+         <key>line</key><integer>736</integer>
          <key>col</key><integer>21</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming the condition is false</string>
      <key>message</key>
      <string>Assuming the condition is false</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>720</integer>
+           <key>line</key><integer>736</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>720</integer>
+           <key>line</key><integer>736</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>723</integer>
+           <key>line</key><integer>739</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>723</integer>
+           <key>line</key><integer>739</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>723</integer>
+           <key>line</key><integer>739</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>723</integer>
+           <key>line</key><integer>739</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>724</integer>
+           <key>line</key><integer>740</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>724</integer>
+           <key>line</key><integer>740</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>724</integer>
+      <key>line</key><integer>740</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>724</integer>
+         <key>line</key><integer>740</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>724</integer>
+         <key>line</key><integer>740</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Incorrect decrement of the reference count of an object that is not owned at this point by the caller</string>
      <key>message</key>
      <string>Incorrect decrement of the reference count of an object that is not owned at this point by the caller</string>
     </dict>
    </array>
    <key>description</key><string>Incorrect decrement of the reference count of an object that is not owned at this point by the caller</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Bad release</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>c8a4713a734a4f6e747423ef88af6bf8</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar_6659160</string>
   <key>issue_hash_function_offset</key><string>33</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>724</integer>
+   <key>line</key><integer>740</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>690</integer>
-    <integer>691</integer>
-    <integer>696</integer>
-    <integer>702</integer>
-    <integer>703</integer>
     <integer>706</integer>
     <integer>707</integer>
-    <integer>714</integer>
-    <integer>715</integer>
-    <integer>716</integer>
-    <integer>717</integer>
+    <integer>712</integer>
     <integer>718</integer>
-    <integer>720</integer>
+    <integer>719</integer>
+    <integer>722</integer>
     <integer>723</integer>
-    <integer>724</integer>
+    <integer>730</integer>
+    <integer>731</integer>
+    <integer>732</integer>
+    <integer>733</integer>
+    <integer>734</integer>
+    <integer>736</integer>
+    <integer>739</integer>
+    <integer>740</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>746</integer>
+      <key>line</key><integer>762</integer>
       <key>col</key><integer>12</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>746</integer>
+         <key>line</key><integer>762</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>746</integer>
+         <key>line</key><integer>762</integer>
          <key>col</key><integer>34</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>746</integer>
+           <key>line</key><integer>762</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>746</integer>
+           <key>line</key><integer>762</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>747</integer>
+           <key>line</key><integer>763</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>747</integer>
+           <key>line</key><integer>763</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>747</integer>
+      <key>line</key><integer>763</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>747</integer>
+         <key>line</key><integer>763</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>747</integer>
+         <key>line</key><integer>763</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>747</integer>
+         <key>line</key><integer>763</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>747</integer>
+         <key>line</key><integer>763</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object released by directly sending the &apos;-dealloc&apos; message</string>
      <key>message</key>
      <string>Object released by directly sending the &apos;-dealloc&apos; message</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>747</integer>
+           <key>line</key><integer>763</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>747</integer>
+           <key>line</key><integer>763</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>748</integer>
+           <key>line</key><integer>764</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>748</integer>
+           <key>line</key><integer>764</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>748</integer>
+      <key>line</key><integer>764</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>748</integer>
+         <key>line</key><integer>764</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>748</integer>
+         <key>line</key><integer>764</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference-counted object is used after it is released</string>
      <key>message</key>
      <string>Reference-counted object is used after it is released</string>
     </dict>
    </array>
    <key>description</key><string>Reference-counted object is used after it is released</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Use-after-release</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>83c7891609f8efb616060d0c6ae6bb43</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>pr3820_ReleaseAfterDealloc</string>
   <key>issue_hash_function_offset</key><string>3</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>748</integer>
+   <key>line</key><integer>764</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>744</integer>
-    <integer>745</integer>
-    <integer>746</integer>
-    <integer>747</integer>
-    <integer>748</integer>
+    <integer>760</integer>
+    <integer>761</integer>
+    <integer>762</integer>
+    <integer>763</integer>
+    <integer>764</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>754</integer>
+           <key>line</key><integer>770</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>754</integer>
+           <key>line</key><integer>770</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>755</integer>
+           <key>line</key><integer>771</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>755</integer>
+           <key>line</key><integer>771</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>755</integer>
+      <key>line</key><integer>771</integer>
       <key>col</key><integer>12</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>755</integer>
+         <key>line</key><integer>771</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>755</integer>
+         <key>line</key><integer>771</integer>
          <key>col</key><integer>34</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>755</integer>
+           <key>line</key><integer>771</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>755</integer>
+           <key>line</key><integer>771</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>756</integer>
+           <key>line</key><integer>772</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>756</integer>
+           <key>line</key><integer>772</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>756</integer>
+      <key>line</key><integer>772</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>756</integer>
+         <key>line</key><integer>772</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>756</integer>
+         <key>line</key><integer>772</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>756</integer>
+         <key>line</key><integer>772</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>756</integer>
+         <key>line</key><integer>772</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object released</string>
      <key>message</key>
      <string>Object released</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>756</integer>
+           <key>line</key><integer>772</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>756</integer>
+           <key>line</key><integer>772</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>757</integer>
+           <key>line</key><integer>773</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>757</integer>
+           <key>line</key><integer>773</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>757</integer>
+      <key>line</key><integer>773</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>757</integer>
+         <key>line</key><integer>773</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>757</integer>
+         <key>line</key><integer>773</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference-counted object is used after it is released</string>
      <key>message</key>
      <string>Reference-counted object is used after it is released</string>
     </dict>
    </array>
    <key>description</key><string>Reference-counted object is used after it is released</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Use-after-release</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>9fe338c720f25b3b1d5a68930d3ae4b8</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>pr3820_DeallocAfterRelease</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>757</integer>
+   <key>line</key><integer>773</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>752</integer>
-    <integer>753</integer>
-    <integer>754</integer>
-    <integer>755</integer>
-    <integer>756</integer>
-    <integer>757</integer>
+    <integer>768</integer>
+    <integer>769</integer>
+    <integer>770</integer>
+    <integer>771</integer>
+    <integer>772</integer>
+    <integer>773</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>809</integer>
+           <key>line</key><integer>825</integer>
            <key>col</key><integer>2</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>809</integer>
+           <key>line</key><integer>825</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>809</integer>
+           <key>line</key><integer>825</integer>
            <key>col</key><integer>31</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>809</integer>
+           <key>line</key><integer>825</integer>
            <key>col</key><integer>31</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>809</integer>
+      <key>line</key><integer>825</integer>
       <key>col</key><integer>31</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>809</integer>
+         <key>line</key><integer>825</integer>
          <key>col</key><integer>31</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>809</integer>
+         <key>line</key><integer>825</integer>
          <key>col</key><integer>76</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an Objective-C object with a +0 retain count</string>
      <key>message</key>
      <string>Method returns an Objective-C object with a +0 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>809</integer>
+      <key>line</key><integer>825</integer>
       <key>col</key><integer>30</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>809</integer>
+         <key>line</key><integer>825</integer>
          <key>col</key><integer>30</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>809</integer>
+         <key>line</key><integer>825</integer>
          <key>col</key><integer>84</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>809</integer>
+         <key>line</key><integer>825</integer>
          <key>col</key><integer>31</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>809</integer>
+         <key>line</key><integer>825</integer>
          <key>col</key><integer>76</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>809</integer>
+           <key>line</key><integer>825</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>809</integer>
+           <key>line</key><integer>825</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>809</integer>
+           <key>line</key><integer>825</integer>
            <key>col</key><integer>2</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>809</integer>
+           <key>line</key><integer>825</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>809</integer>
+           <key>line</key><integer>825</integer>
            <key>col</key><integer>2</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>809</integer>
+           <key>line</key><integer>825</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>813</integer>
+           <key>line</key><integer>829</integer>
            <key>col</key><integer>2</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>813</integer>
+           <key>line</key><integer>829</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>813</integer>
+           <key>line</key><integer>829</integer>
            <key>col</key><integer>2</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>813</integer>
+           <key>line</key><integer>829</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>814</integer>
+           <key>line</key><integer>830</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>814</integer>
+           <key>line</key><integer>830</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>814</integer>
+      <key>line</key><integer>830</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;dict&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;dict&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;dict&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>df3400f53fc437aede21f685ca1955d4</string>
   <key>issue_context_kind</key><string>Objective-C method</string>
   <key>issue_context</key><string>applicationDidFinishLaunching:</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>814</integer>
+   <key>line</key><integer>830</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>808</integer>
-    <integer>809</integer>
-    <integer>811</integer>
-    <integer>813</integer>
-    <integer>814</integer>
+    <integer>824</integer>
+    <integer>825</integer>
+    <integer>827</integer>
+    <integer>829</integer>
+    <integer>830</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>821</integer>
+           <key>line</key><integer>837</integer>
            <key>col</key><integer>2</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>821</integer>
+           <key>line</key><integer>837</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>821</integer>
+           <key>line</key><integer>837</integer>
            <key>col</key><integer>31</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>821</integer>
+           <key>line</key><integer>837</integer>
            <key>col</key><integer>31</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>821</integer>
+      <key>line</key><integer>837</integer>
       <key>col</key><integer>31</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>821</integer>
+         <key>line</key><integer>837</integer>
          <key>col</key><integer>31</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>821</integer>
+         <key>line</key><integer>837</integer>
          <key>col</key><integer>76</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an Objective-C object with a +0 retain count</string>
      <key>message</key>
      <string>Method returns an Objective-C object with a +0 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>821</integer>
+      <key>line</key><integer>837</integer>
       <key>col</key><integer>30</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>821</integer>
+         <key>line</key><integer>837</integer>
          <key>col</key><integer>30</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>821</integer>
+         <key>line</key><integer>837</integer>
          <key>col</key><integer>84</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>821</integer>
+         <key>line</key><integer>837</integer>
          <key>col</key><integer>31</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>821</integer>
+         <key>line</key><integer>837</integer>
          <key>col</key><integer>76</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>821</integer>
+           <key>line</key><integer>837</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>821</integer>
+           <key>line</key><integer>837</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>821</integer>
+           <key>line</key><integer>837</integer>
            <key>col</key><integer>2</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>821</integer>
+           <key>line</key><integer>837</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>821</integer>
+           <key>line</key><integer>837</integer>
            <key>col</key><integer>2</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>821</integer>
+           <key>line</key><integer>837</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>822</integer>
+           <key>line</key><integer>838</integer>
            <key>col</key><integer>2</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>822</integer>
+           <key>line</key><integer>838</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>822</integer>
+           <key>line</key><integer>838</integer>
            <key>col</key><integer>2</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>822</integer>
+           <key>line</key><integer>838</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>822</integer>
+           <key>line</key><integer>838</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>822</integer>
+           <key>line</key><integer>838</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>822</integer>
+      <key>line</key><integer>838</integer>
       <key>col</key><integer>6</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>822</integer>
+         <key>line</key><integer>838</integer>
          <key>col</key><integer>6</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>822</integer>
+         <key>line</key><integer>838</integer>
          <key>col</key><integer>11</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming the condition is false</string>
      <key>message</key>
      <string>Assuming the condition is false</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>822</integer>
+           <key>line</key><integer>838</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>822</integer>
+           <key>line</key><integer>838</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>824</integer>
+           <key>line</key><integer>840</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>824</integer>
+           <key>line</key><integer>840</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>824</integer>
+      <key>line</key><integer>840</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;dict&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;dict&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;dict&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>5104ca579763af0f8c66da3fdc42b95f</string>
   <key>issue_context_kind</key><string>Objective-C method</string>
   <key>issue_context</key><string>radar10102244</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>824</integer>
+   <key>line</key><integer>840</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>820</integer>
-    <integer>821</integer>
-    <integer>822</integer>
-    <integer>824</integer>
+    <integer>836</integer>
+    <integer>837</integer>
+    <integer>838</integer>
+    <integer>840</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>832</integer>
+           <key>line</key><integer>848</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>832</integer>
+           <key>line</key><integer>848</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>833</integer>
+           <key>line</key><integer>849</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>833</integer>
+           <key>line</key><integer>849</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>833</integer>
+      <key>line</key><integer>849</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>833</integer>
+         <key>line</key><integer>849</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>833</integer>
+         <key>line</key><integer>849</integer>
          <key>col</key><integer>34</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an Objective-C object with a +0 retain count</string>
      <key>message</key>
      <string>Method returns an Objective-C object with a +0 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>833</integer>
+           <key>line</key><integer>849</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>833</integer>
+           <key>line</key><integer>849</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>834</integer>
+           <key>line</key><integer>850</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>834</integer>
+           <key>line</key><integer>850</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>834</integer>
+      <key>line</key><integer>850</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>834</integer>
+         <key>line</key><integer>850</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>834</integer>
+         <key>line</key><integer>850</integer>
          <key>col</key><integer>8</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Incorrect decrement of the reference count of an object that is not owned at this point by the caller</string>
      <key>message</key>
      <string>Incorrect decrement of the reference count of an object that is not owned at this point by the caller</string>
     </dict>
    </array>
    <key>description</key><string>Incorrect decrement of the reference count of an object that is not owned at this point by the caller</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Bad release</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>a4a85a3991cb3888217d5c62346107dc</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar_6257780_Case1</string>
   <key>issue_hash_function_offset</key><string>3</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>834</integer>
+   <key>line</key><integer>850</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>831</integer>
-    <integer>832</integer>
-    <integer>833</integer>
-    <integer>834</integer>
+    <integer>847</integer>
+    <integer>848</integer>
+    <integer>849</integer>
+    <integer>850</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>909</integer>
+           <key>line</key><integer>925</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>909</integer>
+           <key>line</key><integer>925</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>910</integer>
+           <key>line</key><integer>926</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>910</integer>
+           <key>line</key><integer>926</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>910</integer>
+      <key>line</key><integer>926</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>910</integer>
+         <key>line</key><integer>926</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>910</integer>
+         <key>line</key><integer>926</integer>
          <key>col</key><integer>36</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of RDar6320065Subclass with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of RDar6320065Subclass with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>910</integer>
+           <key>line</key><integer>926</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>910</integer>
+           <key>line</key><integer>926</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>911</integer>
+           <key>line</key><integer>927</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>911</integer>
+           <key>line</key><integer>927</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>911</integer>
+      <key>line</key><integer>927</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>911</integer>
+         <key>line</key><integer>927</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>911</integer>
+         <key>line</key><integer>927</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;RDar6320065Subclass *&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;RDar6320065Subclass *&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;RDar6320065Subclass *&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>75b7ad344b1d4665d918188bd10429df</string>
   <key>issue_context_kind</key><string>Objective-C method</string>
   <key>issue_context</key><string>_initReturningNewClassBad</string>
   <key>issue_hash_function_offset</key><string>2</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>911</integer>
+   <key>line</key><integer>927</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>908</integer>
-    <integer>909</integer>
-    <integer>910</integer>
-    <integer>911</integer>
+    <integer>924</integer>
+    <integer>925</integer>
+    <integer>926</integer>
+    <integer>927</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>914</integer>
+           <key>line</key><integer>930</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>914</integer>
+           <key>line</key><integer>930</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>915</integer>
+           <key>line</key><integer>931</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>915</integer>
+           <key>line</key><integer>931</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>915</integer>
+      <key>line</key><integer>931</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>915</integer>
+         <key>line</key><integer>931</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>915</integer>
+         <key>line</key><integer>931</integer>
          <key>col</key><integer>43</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of RDar6320065Subclass with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of RDar6320065Subclass with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>915</integer>
+           <key>line</key><integer>931</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>915</integer>
+           <key>line</key><integer>931</integer>
            <key>col</key><integer>6</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>916</integer>
+           <key>line</key><integer>932</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>916</integer>
+           <key>line</key><integer>932</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>916</integer>
+      <key>line</key><integer>932</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>916</integer>
+         <key>line</key><integer>932</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>916</integer>
+         <key>line</key><integer>932</integer>
          <key>col</key><integer>27</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>916</integer>
+         <key>line</key><integer>932</integer>
          <key>col</key><integer>11</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>916</integer>
+         <key>line</key><integer>932</integer>
          <key>col</key><integer>14</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object autoreleased</string>
      <key>message</key>
      <string>Object autoreleased</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>916</integer>
+      <key>line</key><integer>932</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>916</integer>
+         <key>line</key><integer>932</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>916</integer>
+         <key>line</key><integer>932</integer>
          <key>col</key><integer>27</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object with a +0 retain count returned to caller where a +1 (owning) retain count is expected</string>
      <key>message</key>
      <string>Object with a +0 retain count returned to caller where a +1 (owning) retain count is expected</string>
     </dict>
    </array>
    <key>description</key><string>Object with a +0 retain count returned to caller where a +1 (owning) retain count is expected</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Method should return an owned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>791e285d27d610c4c016065dd5addd37</string>
   <key>issue_context_kind</key><string>Objective-C method</string>
   <key>issue_context</key><string>initReturningNewClassBad2</string>
   <key>issue_hash_function_offset</key><string>3</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>916</integer>
+   <key>line</key><integer>932</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>913</integer>
-    <integer>914</integer>
-    <integer>915</integer>
-    <integer>916</integer>
+    <integer>929</integer>
+    <integer>930</integer>
+    <integer>931</integer>
+    <integer>932</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>954</integer>
+      <key>line</key><integer>970</integer>
       <key>col</key><integer>37</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>954</integer>
+         <key>line</key><integer>970</integer>
          <key>col</key><integer>37</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>954</integer>
+         <key>line</key><integer>970</integer>
          <key>col</key><integer>59</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>954</integer>
+      <key>line</key><integer>970</integer>
       <key>col</key><integer>30</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>954</integer>
+         <key>line</key><integer>970</integer>
          <key>col</key><integer>30</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>954</integer>
+         <key>line</key><integer>970</integer>
          <key>col</key><integer>59</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;NSString *&apos; is returned from a method whose name (&apos;NoCopyString&apos;) does not start with &apos;copy&apos;, &apos;mutableCopy&apos;, &apos;alloc&apos; or &apos;new&apos;.  This violates the naming convention rules given in the Memory Management Guide for Cocoa</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;NSString *&apos; is returned from a method whose name (&apos;NoCopyString&apos;) does not start with &apos;copy&apos;, &apos;mutableCopy&apos;, &apos;alloc&apos; or &apos;new&apos;.  This violates the naming convention rules given in the Memory Management Guide for Cocoa</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;NSString *&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak of returned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>58cf9e4228ab9cbe375ddf37d04d45f1</string>
   <key>issue_context_kind</key><string>Objective-C method</string>
   <key>issue_context</key><string>NoCopyString</string>
   <key>issue_hash_function_offset</key><string>0</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>954</integer>
+   <key>line</key><integer>970</integer>
    <key>col</key><integer>30</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>954</integer>
+    <integer>970</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>955</integer>
+      <key>line</key><integer>971</integer>
       <key>col</key><integer>37</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>955</integer>
+         <key>line</key><integer>971</integer>
          <key>col</key><integer>37</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>955</integer>
+         <key>line</key><integer>971</integer>
          <key>col</key><integer>59</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>955</integer>
+      <key>line</key><integer>971</integer>
       <key>col</key><integer>30</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>955</integer>
+         <key>line</key><integer>971</integer>
          <key>col</key><integer>30</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>955</integer>
+         <key>line</key><integer>971</integer>
          <key>col</key><integer>59</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;NSString *&apos; is returned from a method whose name (&apos;noCopyString&apos;) does not start with &apos;copy&apos;, &apos;mutableCopy&apos;, &apos;alloc&apos; or &apos;new&apos;.  This violates the naming convention rules given in the Memory Management Guide for Cocoa</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;NSString *&apos; is returned from a method whose name (&apos;noCopyString&apos;) does not start with &apos;copy&apos;, &apos;mutableCopy&apos;, &apos;alloc&apos; or &apos;new&apos;.  This violates the naming convention rules given in the Memory Management Guide for Cocoa</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;NSString *&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak of returned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>e1b0176b31382e7e75129dd78883c91b</string>
   <key>issue_context_kind</key><string>Objective-C method</string>
   <key>issue_context</key><string>noCopyString</string>
   <key>issue_hash_function_offset</key><string>0</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>955</integer>
+   <key>line</key><integer>971</integer>
    <key>col</key><integer>30</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>955</integer>
+    <integer>971</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>959</integer>
+      <key>line</key><integer>975</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>959</integer>
+         <key>line</key><integer>975</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>959</integer>
+         <key>line</key><integer>975</integer>
          <key>col</key><integer>18</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling &apos;NoCopyString&apos;</string>
      <key>message</key>
      <string>Calling &apos;NoCopyString&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>954</integer>
+      <key>line</key><integer>970</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;test_RDar6859457&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;test_RDar6859457&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>954</integer>
+           <key>line</key><integer>970</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>954</integer>
+           <key>line</key><integer>970</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>954</integer>
+           <key>line</key><integer>970</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>954</integer>
+           <key>line</key><integer>970</integer>
            <key>col</key><integer>35</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>954</integer>
+      <key>line</key><integer>970</integer>
       <key>col</key><integer>37</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>954</integer>
+         <key>line</key><integer>970</integer>
          <key>col</key><integer>37</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>954</integer>
+         <key>line</key><integer>970</integer>
          <key>col</key><integer>59</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>959</integer>
+      <key>line</key><integer>975</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>959</integer>
+         <key>line</key><integer>975</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>959</integer>
+         <key>line</key><integer>975</integer>
          <key>col</key><integer>18</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Returning from &apos;NoCopyString&apos;</string>
      <key>message</key>
      <string>Returning from &apos;NoCopyString&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>959</integer>
+           <key>line</key><integer>975</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>959</integer>
+           <key>line</key><integer>975</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>960</integer>
+           <key>line</key><integer>976</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>960</integer>
+           <key>line</key><integer>976</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>960</integer>
+      <key>line</key><integer>976</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>960</integer>
+         <key>line</key><integer>976</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>960</integer>
+         <key>line</key><integer>976</integer>
          <key>col</key><integer>18</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;NSString *&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;NSString *&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;NSString *&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>5ff4d17e82026ccd84121b0a361fc135</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_RDar6859457</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>960</integer>
+   <key>line</key><integer>976</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>954</integer>
-    <integer>958</integer>
-    <integer>959</integer>
-    <integer>960</integer>
+    <integer>970</integer>
+    <integer>974</integer>
+    <integer>975</integer>
+    <integer>976</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>959</integer>
+           <key>line</key><integer>975</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>959</integer>
+           <key>line</key><integer>975</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>960</integer>
+           <key>line</key><integer>976</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>960</integer>
+           <key>line</key><integer>976</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>960</integer>
+      <key>line</key><integer>976</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>960</integer>
+         <key>line</key><integer>976</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>960</integer>
+         <key>line</key><integer>976</integer>
          <key>col</key><integer>18</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling &apos;noCopyString&apos;</string>
      <key>message</key>
      <string>Calling &apos;noCopyString&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>955</integer>
+      <key>line</key><integer>971</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;test_RDar6859457&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;test_RDar6859457&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>955</integer>
+           <key>line</key><integer>971</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>955</integer>
+           <key>line</key><integer>971</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>955</integer>
+           <key>line</key><integer>971</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>955</integer>
+           <key>line</key><integer>971</integer>
            <key>col</key><integer>35</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>955</integer>
+      <key>line</key><integer>971</integer>
       <key>col</key><integer>37</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>955</integer>
+         <key>line</key><integer>971</integer>
          <key>col</key><integer>37</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>955</integer>
+         <key>line</key><integer>971</integer>
          <key>col</key><integer>59</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>960</integer>
+      <key>line</key><integer>976</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>960</integer>
+         <key>line</key><integer>976</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>960</integer>
+         <key>line</key><integer>976</integer>
          <key>col</key><integer>18</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Returning from &apos;noCopyString&apos;</string>
      <key>message</key>
      <string>Returning from &apos;noCopyString&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>960</integer>
+           <key>line</key><integer>976</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>960</integer>
+           <key>line</key><integer>976</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>961</integer>
+           <key>line</key><integer>977</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>961</integer>
+           <key>line</key><integer>977</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>961</integer>
+      <key>line</key><integer>977</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>961</integer>
+         <key>line</key><integer>977</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>961</integer>
+         <key>line</key><integer>977</integer>
          <key>col</key><integer>54</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;NSString *&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;NSString *&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;NSString *&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>964683651b544d6c1cce0c4ae6961936</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_RDar6859457</string>
   <key>issue_hash_function_offset</key><string>2</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>961</integer>
+   <key>line</key><integer>977</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>954</integer>
-    <integer>955</integer>
-    <integer>958</integer>
-    <integer>959</integer>
-    <integer>960</integer>
-    <integer>961</integer>
+    <integer>970</integer>
+    <integer>971</integer>
+    <integer>974</integer>
+    <integer>975</integer>
+    <integer>976</integer>
+    <integer>977</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>994</integer>
+      <key>line</key><integer>1010</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>994</integer>
+         <key>line</key><integer>1010</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>994</integer>
+         <key>line</key><integer>1010</integer>
          <key>col</key><integer>32</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>994</integer>
+      <key>line</key><integer>1010</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>994</integer>
+         <key>line</key><integer>1010</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>994</integer>
+         <key>line</key><integer>1010</integer>
          <key>col</key><integer>32</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;NSString *&apos; is returned from a method whose name (&apos;:&apos;) does not start with &apos;copy&apos;, &apos;mutableCopy&apos;, &apos;alloc&apos; or &apos;new&apos;.  This violates the naming convention rules given in the Memory Management Guide for Cocoa</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;NSString *&apos; is returned from a method whose name (&apos;:&apos;) does not start with &apos;copy&apos;, &apos;mutableCopy&apos;, &apos;alloc&apos; or &apos;new&apos;.  This violates the naming convention rules given in the Memory Management Guide for Cocoa</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;NSString *&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak of returned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>ca046c4c96c27a0e8c84dd707563bba9</string>
   <key>issue_context_kind</key><string>Objective-C method</string>
   <key>issue_context</key><string>:</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>994</integer>
+   <key>line</key><integer>1010</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>993</integer>
-    <integer>994</integer>
+    <integer>1009</integer>
+    <integer>1010</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1024</integer>
+      <key>line</key><integer>1040</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1024</integer>
+         <key>line</key><integer>1040</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1024</integer>
+         <key>line</key><integer>1040</integer>
          <key>col</key><integer>38</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an Objective-C object with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an Objective-C object with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1024</integer>
+           <key>line</key><integer>1040</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1024</integer>
+           <key>line</key><integer>1040</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1025</integer>
+           <key>line</key><integer>1041</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1025</integer>
+           <key>line</key><integer>1041</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1025</integer>
+      <key>line</key><integer>1041</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1025</integer>
+         <key>line</key><integer>1041</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1025</integer>
+         <key>line</key><integer>1041</integer>
          <key>col</key><integer>42</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;id&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;id&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;id&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>12515c1f2d3343496d32a54ef376347d</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar6902710</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1025</integer>
+   <key>line</key><integer>1041</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1021</integer>
-    <integer>1022</integer>
-    <integer>1023</integer>
-    <integer>1024</integer>
-    <integer>1025</integer>
+    <integer>1037</integer>
+    <integer>1038</integer>
+    <integer>1039</integer>
+    <integer>1040</integer>
+    <integer>1041</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1024</integer>
+           <key>line</key><integer>1040</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1024</integer>
+           <key>line</key><integer>1040</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1025</integer>
+           <key>line</key><integer>1041</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1025</integer>
+           <key>line</key><integer>1041</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1025</integer>
+      <key>line</key><integer>1041</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1025</integer>
+         <key>line</key><integer>1041</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1025</integer>
+         <key>line</key><integer>1041</integer>
          <key>col</key><integer>42</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an Objective-C object with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an Objective-C object with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1025</integer>
+           <key>line</key><integer>1041</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1025</integer>
+           <key>line</key><integer>1041</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1026</integer>
+           <key>line</key><integer>1042</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1026</integer>
+           <key>line</key><integer>1042</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1026</integer>
+      <key>line</key><integer>1042</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1026</integer>
+         <key>line</key><integer>1042</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1026</integer>
+         <key>line</key><integer>1042</integer>
          <key>col</key><integer>43</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;id&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;id&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;id&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>e10d7d441805b9f66c118bfeccf32f29</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar6902710</string>
   <key>issue_hash_function_offset</key><string>2</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1026</integer>
+   <key>line</key><integer>1042</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1021</integer>
-    <integer>1022</integer>
-    <integer>1023</integer>
-    <integer>1024</integer>
-    <integer>1025</integer>
-    <integer>1026</integer>
+    <integer>1037</integer>
+    <integer>1038</integer>
+    <integer>1039</integer>
+    <integer>1040</integer>
+    <integer>1041</integer>
+    <integer>1042</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1024</integer>
+           <key>line</key><integer>1040</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1024</integer>
+           <key>line</key><integer>1040</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1026</integer>
+           <key>line</key><integer>1042</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1026</integer>
+           <key>line</key><integer>1042</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1026</integer>
+      <key>line</key><integer>1042</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1026</integer>
+         <key>line</key><integer>1042</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1026</integer>
+         <key>line</key><integer>1042</integer>
          <key>col</key><integer>43</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns a Core Foundation object of type &apos;CGImageRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Method returns a Core Foundation object of type &apos;CGImageRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1026</integer>
+           <key>line</key><integer>1042</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1026</integer>
+           <key>line</key><integer>1042</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1027</integer>
+           <key>line</key><integer>1043</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1027</integer>
+           <key>line</key><integer>1043</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1027</integer>
+      <key>line</key><integer>1043</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1027</integer>
+         <key>line</key><integer>1043</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1027</integer>
+         <key>line</key><integer>1043</integer>
          <key>col</key><integer>69</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CGImageRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CGImageRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CGImageRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>3ae54947ad02e14773ac126982de301d</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar6902710</string>
   <key>issue_hash_function_offset</key><string>3</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1027</integer>
+   <key>line</key><integer>1043</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1021</integer>
-    <integer>1022</integer>
-    <integer>1023</integer>
-    <integer>1024</integer>
-    <integer>1025</integer>
-    <integer>1026</integer>
-    <integer>1027</integer>
+    <integer>1037</integer>
+    <integer>1038</integer>
+    <integer>1039</integer>
+    <integer>1040</integer>
+    <integer>1041</integer>
+    <integer>1042</integer>
+    <integer>1043</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1024</integer>
+           <key>line</key><integer>1040</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1024</integer>
+           <key>line</key><integer>1040</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1027</integer>
+           <key>line</key><integer>1043</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1027</integer>
+           <key>line</key><integer>1043</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1027</integer>
+      <key>line</key><integer>1043</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1027</integer>
+         <key>line</key><integer>1043</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1027</integer>
+         <key>line</key><integer>1043</integer>
          <key>col</key><integer>69</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns a Core Foundation object of type &apos;CGImageRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Method returns a Core Foundation object of type &apos;CGImageRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1027</integer>
+           <key>line</key><integer>1043</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1027</integer>
+           <key>line</key><integer>1043</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1028</integer>
+           <key>line</key><integer>1044</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1028</integer>
+           <key>line</key><integer>1044</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1028</integer>
+      <key>line</key><integer>1044</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CGImageRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CGImageRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CGImageRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>6dba0d2672617f7eb2c512129fb17bb3</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar6902710</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1028</integer>
+   <key>line</key><integer>1044</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1021</integer>
-    <integer>1022</integer>
-    <integer>1023</integer>
-    <integer>1024</integer>
-    <integer>1025</integer>
-    <integer>1026</integer>
-    <integer>1027</integer>
-    <integer>1028</integer>
+    <integer>1037</integer>
+    <integer>1038</integer>
+    <integer>1039</integer>
+    <integer>1040</integer>
+    <integer>1041</integer>
+    <integer>1042</integer>
+    <integer>1043</integer>
+    <integer>1044</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1036</integer>
+      <key>line</key><integer>1052</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1036</integer>
+         <key>line</key><integer>1052</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1036</integer>
+         <key>line</key><integer>1052</integer>
          <key>col</key><integer>45</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns a Core Foundation object of type &apos;CGLayerRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Method returns a Core Foundation object of type &apos;CGLayerRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1036</integer>
+           <key>line</key><integer>1052</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1036</integer>
+           <key>line</key><integer>1052</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1037</integer>
+           <key>line</key><integer>1053</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1037</integer>
+           <key>line</key><integer>1053</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1037</integer>
+      <key>line</key><integer>1053</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CGLayerRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CGLayerRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CGLayerRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>b065641c4257dac33ff15b08859d09e2</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar6945561</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1037</integer>
+   <key>line</key><integer>1053</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1035</integer>
-    <integer>1036</integer>
-    <integer>1037</integer>
+    <integer>1051</integer>
+    <integer>1052</integer>
+    <integer>1053</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1045</integer>
+      <key>line</key><integer>1061</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1045</integer>
+         <key>line</key><integer>1061</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1045</integer>
+         <key>line</key><integer>1061</integer>
          <key>col</key><integer>49</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;IOBSDNameMatching&apos; returns a Core Foundation object of type &apos;CFMutableDictionaryRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;IOBSDNameMatching&apos; returns a Core Foundation object of type &apos;CFMutableDictionaryRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1045</integer>
+           <key>line</key><integer>1061</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1045</integer>
+           <key>line</key><integer>1061</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1046</integer>
+           <key>line</key><integer>1062</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1046</integer>
+           <key>line</key><integer>1062</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1046</integer>
+      <key>line</key><integer>1062</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableDictionaryRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableDictionaryRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CFMutableDictionaryRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>7cbb4f547b5c1fb1a456ecc47f27d853</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>IOBSDNameMatching_wrapper</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1046</integer>
+   <key>line</key><integer>1062</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1044</integer>
-    <integer>1045</integer>
-    <integer>1046</integer>
+    <integer>1060</integer>
+    <integer>1061</integer>
+    <integer>1062</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1049</integer>
+      <key>line</key><integer>1065</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1049</integer>
+         <key>line</key><integer>1065</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1049</integer>
+         <key>line</key><integer>1065</integer>
          <key>col</key><integer>25</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;IOServiceMatching&apos; returns a Core Foundation object of type &apos;CFMutableDictionaryRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;IOServiceMatching&apos; returns a Core Foundation object of type &apos;CFMutableDictionaryRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1049</integer>
+           <key>line</key><integer>1065</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1049</integer>
+           <key>line</key><integer>1065</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1050</integer>
+           <key>line</key><integer>1066</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1050</integer>
+           <key>line</key><integer>1066</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1050</integer>
+      <key>line</key><integer>1066</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableDictionaryRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableDictionaryRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CFMutableDictionaryRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>0b329ce97e1baf94f89590888a4af794</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>IOServiceMatching_wrapper</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1050</integer>
+   <key>line</key><integer>1066</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1048</integer>
-    <integer>1049</integer>
-    <integer>1050</integer>
+    <integer>1064</integer>
+    <integer>1065</integer>
+    <integer>1066</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1053</integer>
+      <key>line</key><integer>1069</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1053</integer>
+         <key>line</key><integer>1069</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1053</integer>
+         <key>line</key><integer>1069</integer>
          <key>col</key><integer>29</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;IOServiceNameMatching&apos; returns a Core Foundation object of type &apos;CFMutableDictionaryRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;IOServiceNameMatching&apos; returns a Core Foundation object of type &apos;CFMutableDictionaryRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1053</integer>
+           <key>line</key><integer>1069</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1053</integer>
+           <key>line</key><integer>1069</integer>
            <key>col</key><integer>23</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1054</integer>
+           <key>line</key><integer>1070</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1054</integer>
+           <key>line</key><integer>1070</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1054</integer>
+      <key>line</key><integer>1070</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableDictionaryRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableDictionaryRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CFMutableDictionaryRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>e207241fbe4666cffeeca3f47966425f</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>IOServiceNameMatching_wrapper</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1054</integer>
+   <key>line</key><integer>1070</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1052</integer>
-    <integer>1053</integer>
-    <integer>1054</integer>
+    <integer>1068</integer>
+    <integer>1069</integer>
+    <integer>1070</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1061</integer>
+      <key>line</key><integer>1077</integer>
       <key>col</key><integer>30</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1061</integer>
+         <key>line</key><integer>1077</integer>
          <key>col</key><integer>30</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1061</integer>
+         <key>line</key><integer>1077</integer>
          <key>col</key><integer>41</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CreateDict&apos; returns a Core Foundation object of type &apos;CFDictionaryRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CreateDict&apos; returns a Core Foundation object of type &apos;CFDictionaryRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1061</integer>
+           <key>line</key><integer>1077</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1061</integer>
+           <key>line</key><integer>1077</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1062</integer>
+           <key>line</key><integer>1078</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1062</integer>
+           <key>line</key><integer>1078</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1062</integer>
+      <key>line</key><integer>1078</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1062</integer>
+         <key>line</key><integer>1078</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1062</integer>
+         <key>line</key><integer>1078</integer>
          <key>col</key><integer>21</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>1062</integer>
+         <key>line</key><integer>1078</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1062</integer>
+         <key>line</key><integer>1078</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object released</string>
      <key>message</key>
      <string>Object released</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1062</integer>
+           <key>line</key><integer>1078</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1062</integer>
+           <key>line</key><integer>1078</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1063</integer>
+           <key>line</key><integer>1079</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1063</integer>
+           <key>line</key><integer>1079</integer>
            <key>col</key><integer>26</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1063</integer>
+      <key>line</key><integer>1079</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1063</integer>
+         <key>line</key><integer>1079</integer>
          <key>col</key><integer>58</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1063</integer>
+         <key>line</key><integer>1079</integer>
          <key>col</key><integer>65</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference-counted object is used after it is released</string>
      <key>message</key>
      <string>Reference-counted object is used after it is released</string>
     </dict>
    </array>
    <key>description</key><string>Reference-counted object is used after it is released</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Use-after-release</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>ae61d11111bc6c9f049a5ca8935b7bae</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>IOServiceAddNotification_wrapper</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1063</integer>
+   <key>line</key><integer>1079</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1058</integer>
-    <integer>1059</integer>
-    <integer>1061</integer>
-    <integer>1062</integer>
-    <integer>1063</integer>
-    <integer>1064</integer>
+    <integer>1074</integer>
+    <integer>1075</integer>
+    <integer>1077</integer>
+    <integer>1078</integer>
+    <integer>1079</integer>
+    <integer>1080</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1068</integer>
+      <key>line</key><integer>1084</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1068</integer>
+         <key>line</key><integer>1084</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1068</integer>
+         <key>line</key><integer>1084</integer>
          <key>col</key><integer>36</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;IORegistryEntryIDMatching&apos; returns a Core Foundation object of type &apos;CFMutableDictionaryRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;IORegistryEntryIDMatching&apos; returns a Core Foundation object of type &apos;CFMutableDictionaryRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1068</integer>
+           <key>line</key><integer>1084</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1068</integer>
+           <key>line</key><integer>1084</integer>
            <key>col</key><integer>27</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1069</integer>
+           <key>line</key><integer>1085</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1069</integer>
+           <key>line</key><integer>1085</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1069</integer>
+      <key>line</key><integer>1085</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableDictionaryRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableDictionaryRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CFMutableDictionaryRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>62fc802833a96d44d2fa008826c46c64</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>IORegistryEntryIDMatching_wrapper</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1069</integer>
+   <key>line</key><integer>1085</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1067</integer>
-    <integer>1068</integer>
-    <integer>1069</integer>
+    <integer>1083</integer>
+    <integer>1084</integer>
+    <integer>1085</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1073</integer>
+      <key>line</key><integer>1089</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1073</integer>
+         <key>line</key><integer>1089</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1073</integer>
+         <key>line</key><integer>1089</integer>
          <key>col</key><integer>55</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;IOOpenFirmwarePathMatching&apos; returns a Core Foundation object of type &apos;CFMutableDictionaryRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;IOOpenFirmwarePathMatching&apos; returns a Core Foundation object of type &apos;CFMutableDictionaryRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1073</integer>
+           <key>line</key><integer>1089</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1073</integer>
+           <key>line</key><integer>1089</integer>
            <key>col</key><integer>28</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1074</integer>
+           <key>line</key><integer>1090</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1074</integer>
+           <key>line</key><integer>1090</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1074</integer>
+      <key>line</key><integer>1090</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableDictionaryRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableDictionaryRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CFMutableDictionaryRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>644a1e5f3d844a5d9b140de26e6e5645</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>IOOpenFirmwarePathMatching_wrapper</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1074</integer>
+   <key>line</key><integer>1090</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1071</integer>
-    <integer>1072</integer>
-    <integer>1073</integer>
-    <integer>1074</integer>
+    <integer>1087</integer>
+    <integer>1088</integer>
+    <integer>1089</integer>
+    <integer>1090</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1077</integer>
+      <key>line</key><integer>1093</integer>
       <key>col</key><integer>30</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1077</integer>
+         <key>line</key><integer>1093</integer>
          <key>col</key><integer>30</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1077</integer>
+         <key>line</key><integer>1093</integer>
          <key>col</key><integer>41</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CreateDict&apos; returns a Core Foundation object of type &apos;CFDictionaryRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CreateDict&apos; returns a Core Foundation object of type &apos;CFDictionaryRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1077</integer>
+           <key>line</key><integer>1093</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1077</integer>
+           <key>line</key><integer>1093</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1078</integer>
+           <key>line</key><integer>1094</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1078</integer>
+           <key>line</key><integer>1094</integer>
            <key>col</key><integer>29</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1078</integer>
+      <key>line</key><integer>1094</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1078</integer>
+         <key>line</key><integer>1094</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1078</integer>
+         <key>line</key><integer>1094</integer>
          <key>col</key><integer>51</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>1078</integer>
+         <key>line</key><integer>1094</integer>
          <key>col</key><integer>43</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1078</integer>
+         <key>line</key><integer>1094</integer>
          <key>col</key><integer>50</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object released</string>
      <key>message</key>
      <string>Object released</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1078</integer>
+           <key>line</key><integer>1094</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1078</integer>
+           <key>line</key><integer>1094</integer>
            <key>col</key><integer>29</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1079</integer>
+           <key>line</key><integer>1095</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1079</integer>
+           <key>line</key><integer>1095</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1079</integer>
+      <key>line</key><integer>1095</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1079</integer>
+         <key>line</key><integer>1095</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1079</integer>
+         <key>line</key><integer>1095</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference-counted object is used after it is released</string>
      <key>message</key>
      <string>Reference-counted object is used after it is released</string>
     </dict>
    </array>
    <key>description</key><string>Reference-counted object is used after it is released</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Use-after-release</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>904a99d378144e5aa011649cec493695</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>IOServiceGetMatchingService_wrapper</string>
   <key>issue_hash_function_offset</key><string>3</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1079</integer>
+   <key>line</key><integer>1095</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1076</integer>
-    <integer>1077</integer>
-    <integer>1078</integer>
-    <integer>1079</integer>
+    <integer>1092</integer>
+    <integer>1093</integer>
+    <integer>1094</integer>
+    <integer>1095</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1083</integer>
+      <key>line</key><integer>1099</integer>
       <key>col</key><integer>30</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1083</integer>
+         <key>line</key><integer>1099</integer>
          <key>col</key><integer>30</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1083</integer>
+         <key>line</key><integer>1099</integer>
          <key>col</key><integer>41</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CreateDict&apos; returns a Core Foundation object of type &apos;CFDictionaryRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CreateDict&apos; returns a Core Foundation object of type &apos;CFDictionaryRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1083</integer>
+           <key>line</key><integer>1099</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1083</integer>
+           <key>line</key><integer>1099</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1084</integer>
+           <key>line</key><integer>1100</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1084</integer>
+           <key>line</key><integer>1100</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1084</integer>
+      <key>line</key><integer>1100</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1084</integer>
+         <key>line</key><integer>1100</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1084</integer>
+         <key>line</key><integer>1100</integer>
          <key>col</key><integer>62</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>1084</integer>
+         <key>line</key><integer>1100</integer>
          <key>col</key><integer>44</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1084</integer>
+         <key>line</key><integer>1100</integer>
          <key>col</key><integer>51</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object released</string>
      <key>message</key>
      <string>Object released</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1084</integer>
+           <key>line</key><integer>1100</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1084</integer>
+           <key>line</key><integer>1100</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1085</integer>
+           <key>line</key><integer>1101</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1085</integer>
+           <key>line</key><integer>1101</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1085</integer>
+      <key>line</key><integer>1101</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1085</integer>
+         <key>line</key><integer>1101</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1085</integer>
+         <key>line</key><integer>1101</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference-counted object is used after it is released</string>
      <key>message</key>
      <string>Reference-counted object is used after it is released</string>
     </dict>
    </array>
    <key>description</key><string>Reference-counted object is used after it is released</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Use-after-release</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>23c94c459003beb49ea078f75a86ccc5</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>IOServiceGetMatchingServices_wrapper</string>
   <key>issue_hash_function_offset</key><string>3</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1085</integer>
+   <key>line</key><integer>1101</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1082</integer>
-    <integer>1083</integer>
-    <integer>1084</integer>
-    <integer>1085</integer>
+    <integer>1098</integer>
+    <integer>1099</integer>
+    <integer>1100</integer>
+    <integer>1101</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1091</integer>
+      <key>line</key><integer>1107</integer>
       <key>col</key><integer>30</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1091</integer>
+         <key>line</key><integer>1107</integer>
          <key>col</key><integer>30</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1091</integer>
+         <key>line</key><integer>1107</integer>
          <key>col</key><integer>41</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CreateDict&apos; returns a Core Foundation object of type &apos;CFDictionaryRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CreateDict&apos; returns a Core Foundation object of type &apos;CFDictionaryRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1091</integer>
+           <key>line</key><integer>1107</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1091</integer>
+           <key>line</key><integer>1107</integer>
            <key>col</key><integer>17</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1092</integer>
+           <key>line</key><integer>1108</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1092</integer>
+           <key>line</key><integer>1108</integer>
            <key>col</key><integer>34</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1092</integer>
+      <key>line</key><integer>1108</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1092</integer>
+         <key>line</key><integer>1108</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1092</integer>
+         <key>line</key><integer>1108</integer>
          <key>col</key><integer>106</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>1092</integer>
+         <key>line</key><integer>1108</integer>
          <key>col</key><integer>66</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1092</integer>
+         <key>line</key><integer>1108</integer>
          <key>col</key><integer>73</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object released</string>
      <key>message</key>
      <string>Object released</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1092</integer>
+           <key>line</key><integer>1108</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1092</integer>
+           <key>line</key><integer>1108</integer>
            <key>col</key><integer>34</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1093</integer>
+           <key>line</key><integer>1109</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1093</integer>
+           <key>line</key><integer>1109</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1093</integer>
+      <key>line</key><integer>1109</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1093</integer>
+         <key>line</key><integer>1109</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1093</integer>
+         <key>line</key><integer>1109</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference-counted object is used after it is released</string>
      <key>message</key>
      <string>Reference-counted object is used after it is released</string>
     </dict>
    </array>
    <key>description</key><string>Reference-counted object is used after it is released</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Use-after-release</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>06e6fa1f7f96818fbd619dfe8b210b0d</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>IOServiceAddMatchingNotification_wrapper</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1093</integer>
+   <key>line</key><integer>1109</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1088</integer>
-    <integer>1089</integer>
-    <integer>1091</integer>
-    <integer>1092</integer>
-    <integer>1093</integer>
+    <integer>1104</integer>
+    <integer>1105</integer>
+    <integer>1107</integer>
+    <integer>1108</integer>
+    <integer>1109</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1131</integer>
+           <key>line</key><integer>1147</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1131</integer>
+           <key>line</key><integer>1147</integer>
            <key>col</key><integer>23</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1134</integer>
+           <key>line</key><integer>1150</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1134</integer>
+           <key>line</key><integer>1150</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1134</integer>
+      <key>line</key><integer>1150</integer>
       <key>col</key><integer>22</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1134</integer>
+         <key>line</key><integer>1150</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1134</integer>
+         <key>line</key><integer>1150</integer>
          <key>col</key><integer>53</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSNumber with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSNumber with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1134</integer>
+           <key>line</key><integer>1150</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1134</integer>
+           <key>line</key><integer>1150</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1136</integer>
+           <key>line</key><integer>1152</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1136</integer>
+           <key>line</key><integer>1152</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1136</integer>
+      <key>line</key><integer>1152</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1136</integer>
+         <key>line</key><integer>1152</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1136</integer>
+         <key>line</key><integer>1152</integer>
          <key>col</key><integer>18</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>1136</integer>
+         <key>line</key><integer>1152</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1136</integer>
+         <key>line</key><integer>1152</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count decremented</string>
      <key>message</key>
      <string>Reference count decremented</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1136</integer>
+           <key>line</key><integer>1152</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1136</integer>
+           <key>line</key><integer>1152</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1137</integer>
+           <key>line</key><integer>1153</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1137</integer>
+           <key>line</key><integer>1153</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1137</integer>
+      <key>line</key><integer>1153</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1137</integer>
+         <key>line</key><integer>1153</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1137</integer>
+         <key>line</key><integer>1153</integer>
          <key>col</key><integer>17</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>1137</integer>
+         <key>line</key><integer>1153</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1137</integer>
+         <key>line</key><integer>1153</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1137</integer>
+           <key>line</key><integer>1153</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1137</integer>
+           <key>line</key><integer>1153</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1138</integer>
+           <key>line</key><integer>1154</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1138</integer>
+           <key>line</key><integer>1154</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1138</integer>
+      <key>line</key><integer>1154</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1138</integer>
+         <key>line</key><integer>1154</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1138</integer>
+         <key>line</key><integer>1154</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;number&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;number&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;number&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>1692047c1a2ab283584ae01c84e3ae35</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar_7152619</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1138</integer>
+   <key>line</key><integer>1154</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>67</integer>
-    <integer>68</integer>
-    <integer>69</integer>
-    <integer>70</integer>
-    <integer>71</integer>
-    <integer>1130</integer>
-    <integer>1131</integer>
-    <integer>1132</integer>
-    <integer>1133</integer>
-    <integer>1134</integer>
-    <integer>1135</integer>
-    <integer>1136</integer>
-    <integer>1137</integer>
-    <integer>1138</integer>
+    <integer>74</integer>
+    <integer>75</integer>
+    <integer>76</integer>
+    <integer>77</integer>
+    <integer>78</integer>
+    <integer>1146</integer>
+    <integer>1147</integer>
+    <integer>1148</integer>
+    <integer>1149</integer>
+    <integer>1150</integer>
+    <integer>1151</integer>
+    <integer>1152</integer>
+    <integer>1153</integer>
+    <integer>1154</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1147</integer>
+           <key>line</key><integer>1163</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1147</integer>
+           <key>line</key><integer>1163</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1158</integer>
+           <key>line</key><integer>1174</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1158</integer>
+           <key>line</key><integer>1174</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1158</integer>
+           <key>line</key><integer>1174</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1158</integer>
+           <key>line</key><integer>1174</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1159</integer>
+           <key>line</key><integer>1175</integer>
            <key>col</key><integer>41</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1159</integer>
+           <key>line</key><integer>1175</integer>
            <key>col</key><integer>67</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1159</integer>
+      <key>line</key><integer>1175</integer>
       <key>col</key><integer>41</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1159</integer>
+         <key>line</key><integer>1175</integer>
          <key>col</key><integer>41</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1159</integer>
+         <key>line</key><integer>1175</integer>
          <key>col</key><integer>69</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CGColorSpaceCreateDeviceRGB&apos; returns a Core Foundation object of type &apos;CGColorSpaceRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CGColorSpaceCreateDeviceRGB&apos; returns a Core Foundation object of type &apos;CGColorSpaceRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1159</integer>
+           <key>line</key><integer>1175</integer>
            <key>col</key><integer>41</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1159</integer>
+           <key>line</key><integer>1175</integer>
            <key>col</key><integer>67</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1158</integer>
+           <key>line</key><integer>1174</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1158</integer>
+           <key>line</key><integer>1174</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1158</integer>
+      <key>line</key><integer>1174</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1158</integer>
+         <key>line</key><integer>1174</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1158</integer>
+         <key>line</key><integer>1174</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CGColorSpaceRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CGColorSpaceRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CGColorSpaceRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>17e5c3184216ca3aef86288dc1f41d8d</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar_7184450</string>
   <key>issue_hash_function_offset</key><string>13</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1158</integer>
+   <key>line</key><integer>1174</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1145</integer>
-    <integer>1146</integer>
-    <integer>1147</integer>
-    <integer>1148</integer>
-    <integer>1149</integer>
-    <integer>1150</integer>
-    <integer>1151</integer>
-    <integer>1152</integer>
-    <integer>1153</integer>
-    <integer>1154</integer>
-    <integer>1155</integer>
-    <integer>1158</integer>
-    <integer>1159</integer>
-    <integer>1160</integer>
+    <integer>1161</integer>
+    <integer>1162</integer>
+    <integer>1163</integer>
+    <integer>1164</integer>
+    <integer>1165</integer>
+    <integer>1166</integer>
+    <integer>1167</integer>
+    <integer>1168</integer>
+    <integer>1169</integer>
+    <integer>1170</integer>
+    <integer>1171</integer>
+    <integer>1174</integer>
+    <integer>1175</integer>
+    <integer>1176</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1169</integer>
+           <key>line</key><integer>1185</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1169</integer>
+           <key>line</key><integer>1185</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1180</integer>
+           <key>line</key><integer>1196</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1180</integer>
+           <key>line</key><integer>1196</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1180</integer>
+           <key>line</key><integer>1196</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1180</integer>
+           <key>line</key><integer>1196</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1181</integer>
+           <key>line</key><integer>1197</integer>
            <key>col</key><integer>40</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1181</integer>
+           <key>line</key><integer>1197</integer>
            <key>col</key><integer>66</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1181</integer>
+      <key>line</key><integer>1197</integer>
       <key>col</key><integer>40</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1181</integer>
+         <key>line</key><integer>1197</integer>
          <key>col</key><integer>40</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1181</integer>
+         <key>line</key><integer>1197</integer>
          <key>col</key><integer>68</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CGColorSpaceCreateDeviceRGB&apos; returns a Core Foundation object of type &apos;CGColorSpaceRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CGColorSpaceCreateDeviceRGB&apos; returns a Core Foundation object of type &apos;CGColorSpaceRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1181</integer>
+           <key>line</key><integer>1197</integer>
            <key>col</key><integer>40</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1181</integer>
+           <key>line</key><integer>1197</integer>
            <key>col</key><integer>66</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1180</integer>
+           <key>line</key><integer>1196</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1180</integer>
+           <key>line</key><integer>1196</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1180</integer>
+      <key>line</key><integer>1196</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1180</integer>
+         <key>line</key><integer>1196</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1180</integer>
+         <key>line</key><integer>1196</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CGColorSpaceRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CGColorSpaceRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CGColorSpaceRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>c2225660bdec84d2ae183eda303a1abb</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar_7184450_pos</string>
   <key>issue_hash_function_offset</key><string>13</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1180</integer>
+   <key>line</key><integer>1196</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1167</integer>
-    <integer>1168</integer>
-    <integer>1169</integer>
-    <integer>1170</integer>
-    <integer>1171</integer>
-    <integer>1172</integer>
-    <integer>1173</integer>
-    <integer>1174</integer>
-    <integer>1175</integer>
-    <integer>1176</integer>
-    <integer>1177</integer>
-    <integer>1180</integer>
-    <integer>1181</integer>
+    <integer>1183</integer>
+    <integer>1184</integer>
+    <integer>1185</integer>
+    <integer>1186</integer>
+    <integer>1187</integer>
+    <integer>1188</integer>
+    <integer>1189</integer>
+    <integer>1190</integer>
+    <integer>1191</integer>
+    <integer>1192</integer>
+    <integer>1193</integer>
+    <integer>1196</integer>
+    <integer>1197</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1169</integer>
+           <key>line</key><integer>1185</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1169</integer>
+           <key>line</key><integer>1185</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1180</integer>
+           <key>line</key><integer>1196</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1180</integer>
+           <key>line</key><integer>1196</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1180</integer>
+           <key>line</key><integer>1196</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1180</integer>
+           <key>line</key><integer>1196</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1181</integer>
+           <key>line</key><integer>1197</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1181</integer>
+           <key>line</key><integer>1197</integer>
            <key>col</key><integer>38</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1181</integer>
+      <key>line</key><integer>1197</integer>
       <key>col</key><integer>4</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1181</integer>
+         <key>line</key><integer>1197</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1181</integer>
+         <key>line</key><integer>1197</integer>
          <key>col</key><integer>107</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CGGradientCreateWithColorComponents&apos; returns a Core Foundation object of type &apos;CGGradientRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CGGradientCreateWithColorComponents&apos; returns a Core Foundation object of type &apos;CGGradientRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1181</integer>
+           <key>line</key><integer>1197</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1181</integer>
+           <key>line</key><integer>1197</integer>
            <key>col</key><integer>38</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1183</integer>
+           <key>line</key><integer>1199</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1183</integer>
+           <key>line</key><integer>1199</integer>
            <key>col</key><integer>29</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1183</integer>
+           <key>line</key><integer>1199</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1183</integer>
+           <key>line</key><integer>1199</integer>
            <key>col</key><integer>29</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1185</integer>
+           <key>line</key><integer>1201</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1185</integer>
+           <key>line</key><integer>1201</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1185</integer>
+      <key>line</key><integer>1201</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;myGradient&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;myGradient&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;myGradient&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>6415d6b7dd7d48a2ef27f4c4d0168c64</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar_7184450_pos</string>
   <key>issue_hash_function_offset</key><string>13</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1185</integer>
+   <key>line</key><integer>1201</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1167</integer>
-    <integer>1168</integer>
-    <integer>1169</integer>
-    <integer>1170</integer>
-    <integer>1171</integer>
-    <integer>1172</integer>
-    <integer>1173</integer>
-    <integer>1174</integer>
-    <integer>1175</integer>
-    <integer>1176</integer>
-    <integer>1177</integer>
-    <integer>1180</integer>
-    <integer>1181</integer>
     <integer>1183</integer>
     <integer>1184</integer>
     <integer>1185</integer>
+    <integer>1186</integer>
+    <integer>1187</integer>
+    <integer>1188</integer>
+    <integer>1189</integer>
+    <integer>1190</integer>
+    <integer>1191</integer>
+    <integer>1192</integer>
+    <integer>1193</integer>
+    <integer>1196</integer>
+    <integer>1197</integer>
+    <integer>1199</integer>
+    <integer>1200</integer>
+    <integer>1201</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1219</integer>
+      <key>line</key><integer>1235</integer>
       <key>col</key><integer>22</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1219</integer>
+         <key>line</key><integer>1235</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1219</integer>
+         <key>line</key><integer>1235</integer>
          <key>col</key><integer>53</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSNumber with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSNumber with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1219</integer>
+           <key>line</key><integer>1235</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1219</integer>
+           <key>line</key><integer>1235</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1220</integer>
+           <key>line</key><integer>1236</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1220</integer>
+           <key>line</key><integer>1236</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1220</integer>
+      <key>line</key><integer>1236</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;number&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;number&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;number&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>08a69979bb4fa932512da1327fbf3b23</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar_7299394_positive</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1220</integer>
+   <key>line</key><integer>1236</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1218</integer>
-    <integer>1219</integer>
-    <integer>1220</integer>
+    <integer>1234</integer>
+    <integer>1235</integer>
+    <integer>1236</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1454</integer>
+           <key>line</key><integer>1470</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1454</integer>
+           <key>line</key><integer>1470</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1456</integer>
+           <key>line</key><integer>1472</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1456</integer>
+           <key>line</key><integer>1472</integer>
            <key>col</key><integer>31</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1456</integer>
+      <key>line</key><integer>1472</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1456</integer>
+         <key>line</key><integer>1472</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1457</integer>
+         <key>line</key><integer>1473</integer>
          <key>col</key><integer>60</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CGBitmapContextCreateWithData&apos; returns a Core Foundation object of type &apos;CGContextRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CGBitmapContextCreateWithData&apos; returns a Core Foundation object of type &apos;CGContextRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1456</integer>
+           <key>line</key><integer>1472</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1456</integer>
+           <key>line</key><integer>1472</integer>
            <key>col</key><integer>31</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1458</integer>
+           <key>line</key><integer>1474</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1458</integer>
+           <key>line</key><integer>1474</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1458</integer>
+      <key>line</key><integer>1474</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CGContextRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CGContextRef&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CGContextRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>32b76a1b35c681cad8093c7e79e36388</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar_7358899</string>
   <key>issue_hash_function_offset</key><string>7</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1458</integer>
+   <key>line</key><integer>1474</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1446</integer>
-    <integer>1447</integer>
-    <integer>1448</integer>
-    <integer>1449</integer>
-    <integer>1454</integer>
-    <integer>1456</integer>
-    <integer>1457</integer>
-    <integer>1458</integer>
+    <integer>1462</integer>
+    <integer>1463</integer>
+    <integer>1464</integer>
+    <integer>1465</integer>
+    <integer>1470</integer>
+    <integer>1472</integer>
+    <integer>1473</integer>
+    <integer>1474</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1474</integer>
+      <key>line</key><integer>1490</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1474</integer>
+         <key>line</key><integer>1490</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1474</integer>
+         <key>line</key><integer>1490</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an Objective-C object with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an Objective-C object with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1474</integer>
+           <key>line</key><integer>1490</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1474</integer>
+           <key>line</key><integer>1490</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1475</integer>
+           <key>line</key><integer>1491</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1475</integer>
+           <key>line</key><integer>1491</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1475</integer>
+      <key>line</key><integer>1491</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;y&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;y&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;y&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>7e6172f0b4b6af27712153519e1934e1</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar7265711_a</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1475</integer>
+   <key>line</key><integer>1491</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1473</integer>
-    <integer>1474</integer>
-    <integer>1475</integer>
+    <integer>1489</integer>
+    <integer>1490</integer>
+    <integer>1491</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1494</integer>
+           <key>line</key><integer>1510</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1494</integer>
+           <key>line</key><integer>1510</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1495</integer>
+           <key>line</key><integer>1511</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1495</integer>
+           <key>line</key><integer>1511</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1495</integer>
+      <key>line</key><integer>1511</integer>
       <key>col</key><integer>22</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1495</integer>
+         <key>line</key><integer>1511</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1495</integer>
+         <key>line</key><integer>1511</integer>
          <key>col</key><integer>53</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSNumber with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSNumber with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1495</integer>
+           <key>line</key><integer>1511</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1495</integer>
+           <key>line</key><integer>1511</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1496</integer>
+           <key>line</key><integer>1512</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1496</integer>
+           <key>line</key><integer>1512</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1496</integer>
+      <key>line</key><integer>1512</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;number&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;number&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;number&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>5eb97f906bb3af4befe63c891484f791</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar7306898</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1496</integer>
+   <key>line</key><integer>1512</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1491</integer>
-    <integer>1494</integer>
-    <integer>1495</integer>
-    <integer>1496</integer>
+    <integer>1507</integer>
+    <integer>1510</integer>
+    <integer>1511</integer>
+    <integer>1512</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1505</integer>
+      <key>line</key><integer>1521</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1505</integer>
+         <key>line</key><integer>1521</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1505</integer>
+         <key>line</key><integer>1521</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>The &apos;release&apos; message should be sent to instances of class &apos;RDar7252064&apos; and not the class directly</string>
      <key>message</key>
      <string>The &apos;release&apos; message should be sent to instances of class &apos;RDar7252064&apos; and not the class directly</string>
     </dict>
    </array>
    <key>description</key><string>The &apos;release&apos; message should be sent to instances of class &apos;RDar7252064&apos; and not the class directly</string>
    <key>category</key><string>API Misuse (Apple)</string>
    <key>type</key><string>message incorrectly sent to class instead of class instance</string>
    <key>check_name</key><string>osx.cocoa.ClassRelease</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>bdc4aaf3d712232f4ae72dce230189f9</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar7252064</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1505</integer>
+   <key>line</key><integer>1521</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1504</integer>
-    <integer>1505</integer>
+    <integer>1520</integer>
+    <integer>1521</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1505</integer>
+           <key>line</key><integer>1521</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1505</integer>
+           <key>line</key><integer>1521</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1506</integer>
+           <key>line</key><integer>1522</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1506</integer>
+           <key>line</key><integer>1522</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1506</integer>
+      <key>line</key><integer>1522</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1506</integer>
+         <key>line</key><integer>1522</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1506</integer>
+         <key>line</key><integer>1522</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>The &apos;retain&apos; message should be sent to instances of class &apos;RDar7252064&apos; and not the class directly</string>
      <key>message</key>
      <string>The &apos;retain&apos; message should be sent to instances of class &apos;RDar7252064&apos; and not the class directly</string>
     </dict>
    </array>
    <key>description</key><string>The &apos;retain&apos; message should be sent to instances of class &apos;RDar7252064&apos; and not the class directly</string>
    <key>category</key><string>API Misuse (Apple)</string>
    <key>type</key><string>message incorrectly sent to class instead of class instance</string>
    <key>check_name</key><string>osx.cocoa.ClassRelease</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>b767178ef573c7bd520dc62faabc32fc</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar7252064</string>
   <key>issue_hash_function_offset</key><string>2</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1506</integer>
+   <key>line</key><integer>1522</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1504</integer>
-    <integer>1505</integer>
-    <integer>1506</integer>
+    <integer>1520</integer>
+    <integer>1521</integer>
+    <integer>1522</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1505</integer>
+           <key>line</key><integer>1521</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1505</integer>
+           <key>line</key><integer>1521</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1507</integer>
+           <key>line</key><integer>1523</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1507</integer>
+           <key>line</key><integer>1523</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1507</integer>
+      <key>line</key><integer>1523</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1507</integer>
+         <key>line</key><integer>1523</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1507</integer>
+         <key>line</key><integer>1523</integer>
          <key>col</key><integer>27</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>The &apos;autorelease&apos; message should be sent to instances of class &apos;RDar7252064&apos; and not the class directly</string>
      <key>message</key>
      <string>The &apos;autorelease&apos; message should be sent to instances of class &apos;RDar7252064&apos; and not the class directly</string>
     </dict>
    </array>
    <key>description</key><string>The &apos;autorelease&apos; message should be sent to instances of class &apos;RDar7252064&apos; and not the class directly</string>
    <key>category</key><string>API Misuse (Apple)</string>
    <key>type</key><string>message incorrectly sent to class instead of class instance</string>
    <key>check_name</key><string>osx.cocoa.ClassRelease</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>3dbe304966f8bffa6bdefc5f3ada7df6</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar7252064</string>
   <key>issue_hash_function_offset</key><string>3</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1507</integer>
+   <key>line</key><integer>1523</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1504</integer>
-    <integer>1505</integer>
-    <integer>1506</integer>
-    <integer>1507</integer>
+    <integer>1520</integer>
+    <integer>1521</integer>
+    <integer>1522</integer>
+    <integer>1523</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1505</integer>
+           <key>line</key><integer>1521</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1505</integer>
+           <key>line</key><integer>1521</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1508</integer>
+           <key>line</key><integer>1524</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1508</integer>
+           <key>line</key><integer>1524</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1508</integer>
+      <key>line</key><integer>1524</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1508</integer>
+         <key>line</key><integer>1524</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1508</integer>
+         <key>line</key><integer>1524</integer>
          <key>col</key><integer>27</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>The &apos;drain&apos; message should be sent to instances of class &apos;NSAutoreleasePool&apos; and not the class directly</string>
      <key>message</key>
      <string>The &apos;drain&apos; message should be sent to instances of class &apos;NSAutoreleasePool&apos; and not the class directly</string>
     </dict>
    </array>
    <key>description</key><string>The &apos;drain&apos; message should be sent to instances of class &apos;NSAutoreleasePool&apos; and not the class directly</string>
    <key>category</key><string>API Misuse (Apple)</string>
    <key>type</key><string>message incorrectly sent to class instead of class instance</string>
    <key>check_name</key><string>osx.cocoa.ClassRelease</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>c519bce30f1da4bb6e3ecc46453d6958</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar7252064</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1508</integer>
+   <key>line</key><integer>1524</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1504</integer>
-    <integer>1505</integer>
-    <integer>1506</integer>
-    <integer>1507</integer>
-    <integer>1508</integer>
+    <integer>1520</integer>
+    <integer>1521</integer>
+    <integer>1522</integer>
+    <integer>1523</integer>
+    <integer>1524</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1535</integer>
+      <key>line</key><integer>1551</integer>
       <key>col</key><integer>19</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1535</integer>
+         <key>line</key><integer>1551</integer>
          <key>col</key><integer>19</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1535</integer>
+         <key>line</key><integer>1551</integer>
          <key>col</key><integer>42</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1535</integer>
+           <key>line</key><integer>1551</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1535</integer>
+           <key>line</key><integer>1551</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1536</integer>
+           <key>line</key><integer>1552</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1536</integer>
+           <key>line</key><integer>1552</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1536</integer>
+      <key>line</key><integer>1552</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;str&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;str&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;str&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>6b9b51ce7b68ca0ba6a85e8924601a96</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_attr_1</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1536</integer>
+   <key>line</key><integer>1552</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1534</integer>
-    <integer>1535</integer>
-    <integer>1536</integer>
+    <integer>1550</integer>
+    <integer>1551</integer>
+    <integer>1552</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1539</integer>
+      <key>line</key><integer>1555</integer>
       <key>col</key><integer>19</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1539</integer>
+         <key>line</key><integer>1555</integer>
          <key>col</key><integer>19</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1539</integer>
+         <key>line</key><integer>1555</integer>
          <key>col</key><integer>44</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns a Core Foundation object of type &apos;NSString *&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Method returns a Core Foundation object of type &apos;NSString *&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1539</integer>
+           <key>line</key><integer>1555</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1539</integer>
+           <key>line</key><integer>1555</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1540</integer>
+           <key>line</key><integer>1556</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1540</integer>
+           <key>line</key><integer>1556</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1540</integer>
+      <key>line</key><integer>1556</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;str&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;str&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;str&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>eb040d5ec198d092ec9894af4dce6af8</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_attr_1b</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1540</integer>
+   <key>line</key><integer>1556</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1538</integer>
-    <integer>1539</integer>
-    <integer>1540</integer>
+    <integer>1554</integer>
+    <integer>1555</integer>
+    <integer>1556</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1543</integer>
+           <key>line</key><integer>1559</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1543</integer>
+           <key>line</key><integer>1559</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1544</integer>
+           <key>line</key><integer>1560</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1544</integer>
+           <key>line</key><integer>1560</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1544</integer>
+      <key>line</key><integer>1560</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1544</integer>
+         <key>line</key><integer>1560</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1544</integer>
+         <key>line</key><integer>1560</integer>
          <key>col</key><integer>38</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1544</integer>
+           <key>line</key><integer>1560</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1544</integer>
+           <key>line</key><integer>1560</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1545</integer>
+           <key>line</key><integer>1561</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1545</integer>
+           <key>line</key><integer>1561</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1545</integer>
+           <key>line</key><integer>1561</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1545</integer>
+           <key>line</key><integer>1561</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1545</integer>
+           <key>line</key><integer>1561</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1545</integer>
+           <key>line</key><integer>1561</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1545</integer>
+      <key>line</key><integer>1561</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1545</integer>
+         <key>line</key><integer>1561</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1545</integer>
+         <key>line</key><integer>1561</integer>
          <key>col</key><integer>37</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;str2&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;str2&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;str2&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>21b45a41bb0c3c70a0efe89359ff3385</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_attr1c</string>
   <key>issue_hash_function_offset</key><string>2</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1545</integer>
+   <key>line</key><integer>1561</integer>
    <key>col</key><integer>20</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1542</integer>
-    <integer>1543</integer>
-    <integer>1544</integer>
-    <integer>1545</integer>
+    <integer>1558</integer>
+    <integer>1559</integer>
+    <integer>1560</integer>
+    <integer>1561</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1543</integer>
+           <key>line</key><integer>1559</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1543</integer>
+           <key>line</key><integer>1559</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1546</integer>
+           <key>line</key><integer>1562</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1546</integer>
+           <key>line</key><integer>1562</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1546</integer>
+           <key>line</key><integer>1562</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1546</integer>
+           <key>line</key><integer>1562</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1546</integer>
+           <key>line</key><integer>1562</integer>
            <key>col</key><integer>21</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1546</integer>
+           <key>line</key><integer>1562</integer>
            <key>col</key><integer>21</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1546</integer>
+      <key>line</key><integer>1562</integer>
       <key>col</key><integer>21</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1546</integer>
+         <key>line</key><integer>1562</integer>
          <key>col</key><integer>21</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1546</integer>
+         <key>line</key><integer>1562</integer>
          <key>col</key><integer>38</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSString with a +0 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSString with a +0 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1546</integer>
+      <key>line</key><integer>1562</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1546</integer>
+         <key>line</key><integer>1562</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1546</integer>
+         <key>line</key><integer>1562</integer>
          <key>col</key><integer>46</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>1546</integer>
+         <key>line</key><integer>1562</integer>
          <key>col</key><integer>21</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1546</integer>
+         <key>line</key><integer>1562</integer>
          <key>col</key><integer>38</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1546</integer>
+           <key>line</key><integer>1562</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1546</integer>
+           <key>line</key><integer>1562</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1546</integer>
+           <key>line</key><integer>1562</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1546</integer>
+           <key>line</key><integer>1562</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1546</integer>
+           <key>line</key><integer>1562</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1546</integer>
+           <key>line</key><integer>1562</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1547</integer>
+           <key>line</key><integer>1563</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1547</integer>
+           <key>line</key><integer>1563</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1547</integer>
+      <key>line</key><integer>1563</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;str4&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;str4&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;str4&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>60396abae77bacd747ea9081b63a32db</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_attr1c</string>
   <key>issue_hash_function_offset</key><string>4</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1547</integer>
+   <key>line</key><integer>1563</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1542</integer>
-    <integer>1543</integer>
-    <integer>1544</integer>
-    <integer>1545</integer>
-    <integer>1546</integer>
-    <integer>1547</integer>
+    <integer>1558</integer>
+    <integer>1559</integer>
+    <integer>1560</integer>
+    <integer>1561</integer>
+    <integer>1562</integer>
+    <integer>1563</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1550</integer>
+      <key>line</key><integer>1566</integer>
       <key>col</key><integer>26</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1550</integer>
+         <key>line</key><integer>1566</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1550</integer>
+         <key>line</key><integer>1566</integer>
          <key>col</key><integer>50</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of TestOwnershipAttr with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of TestOwnershipAttr with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1550</integer>
+           <key>line</key><integer>1566</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1550</integer>
+           <key>line</key><integer>1566</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1551</integer>
+           <key>line</key><integer>1567</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1551</integer>
+           <key>line</key><integer>1567</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1551</integer>
+      <key>line</key><integer>1567</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;x&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;x&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;x&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>e258a710e07550a3dc5f47361a7380e1</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testattr2_a</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1551</integer>
+   <key>line</key><integer>1567</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1549</integer>
-    <integer>1550</integer>
-    <integer>1551</integer>
+    <integer>1565</integer>
+    <integer>1566</integer>
+    <integer>1567</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1554</integer>
+      <key>line</key><integer>1570</integer>
       <key>col</key><integer>26</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1554</integer>
+         <key>line</key><integer>1570</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1554</integer>
+         <key>line</key><integer>1570</integer>
          <key>col</key><integer>63</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an Objective-C object with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an Objective-C object with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1554</integer>
+           <key>line</key><integer>1570</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1554</integer>
+           <key>line</key><integer>1570</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1555</integer>
+           <key>line</key><integer>1571</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1555</integer>
+           <key>line</key><integer>1571</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1555</integer>
+      <key>line</key><integer>1571</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;x&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;x&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;x&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>dc245145c78c3421392a20775cdd6f23</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testattr2_b</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1555</integer>
+   <key>line</key><integer>1571</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1553</integer>
-    <integer>1554</integer>
-    <integer>1555</integer>
+    <integer>1569</integer>
+    <integer>1570</integer>
+    <integer>1571</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1558</integer>
+      <key>line</key><integer>1574</integer>
       <key>col</key><integer>26</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1558</integer>
+         <key>line</key><integer>1574</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1558</integer>
+         <key>line</key><integer>1574</integer>
          <key>col</key><integer>63</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an Objective-C object with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an Objective-C object with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1558</integer>
+           <key>line</key><integer>1574</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1558</integer>
+           <key>line</key><integer>1574</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1559</integer>
+           <key>line</key><integer>1575</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1559</integer>
+           <key>line</key><integer>1575</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1559</integer>
+           <key>line</key><integer>1575</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1559</integer>
+           <key>line</key><integer>1575</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1560</integer>
+           <key>line</key><integer>1576</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1560</integer>
+           <key>line</key><integer>1576</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1560</integer>
+      <key>line</key><integer>1576</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;x&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;x&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;x&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>77b970319b12b0c189e46ad65fa848c7</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>testattr2_b_11358224_self_assign_looses_the_leak</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1560</integer>
+   <key>line</key><integer>1576</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1557</integer>
-    <integer>1558</integer>
-    <integer>1559</integer>
-    <integer>1560</integer>
+    <integer>1573</integer>
+    <integer>1574</integer>
+    <integer>1575</integer>
+    <integer>1576</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1590</integer>
+      <key>line</key><integer>1606</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1590</integer>
+         <key>line</key><integer>1606</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1590</integer>
+         <key>line</key><integer>1606</integer>
          <key>col</key><integer>25</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1590</integer>
+      <key>line</key><integer>1606</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1590</integer>
+         <key>line</key><integer>1606</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1590</integer>
+         <key>line</key><integer>1606</integer>
          <key>col</key><integer>25</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;NSString *&apos; is returned from a method that is annotated as NS_RETURNS_NOT_RETAINED</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;NSString *&apos; is returned from a method that is annotated as NS_RETURNS_NOT_RETAINED</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;NSString *&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak of returned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>4a8d774d2b821ce1601df7edabf66097</string>
   <key>issue_context_kind</key><string>Objective-C method</string>
   <key>issue_context</key><string>newString</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1590</integer>
+   <key>line</key><integer>1606</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1589</integer>
-    <integer>1590</integer>
+    <integer>1605</integer>
+    <integer>1606</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1623</integer>
+           <key>line</key><integer>1639</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1623</integer>
+           <key>line</key><integer>1639</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1623</integer>
+           <key>line</key><integer>1639</integer>
            <key>col</key><integer>26</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1623</integer>
+           <key>line</key><integer>1639</integer>
            <key>col</key><integer>26</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1623</integer>
+      <key>line</key><integer>1639</integer>
       <key>col</key><integer>26</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1623</integer>
+         <key>line</key><integer>1639</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1623</integer>
+         <key>line</key><integer>1639</integer>
          <key>col</key><integer>53</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling &apos;returnsCFRetainedAsCF&apos;</string>
      <key>message</key>
      <string>Calling &apos;returnsCFRetainedAsCF&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1614</integer>
+      <key>line</key><integer>1630</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;newCFRetainedAsCFNoAttr&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;newCFRetainedAsCFNoAttr&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1614</integer>
+           <key>line</key><integer>1630</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1614</integer>
+           <key>line</key><integer>1630</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1615</integer>
+           <key>line</key><integer>1631</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1615</integer>
+           <key>line</key><integer>1631</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1615</integer>
+           <key>line</key><integer>1631</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1615</integer>
+           <key>line</key><integer>1631</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1615</integer>
+           <key>line</key><integer>1631</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1615</integer>
+           <key>line</key><integer>1631</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1615</integer>
+      <key>line</key><integer>1631</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1615</integer>
+         <key>line</key><integer>1631</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1615</integer>
+         <key>line</key><integer>1631</integer>
          <key>col</key><integer>32</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Calling &apos;returnsRetainedCFDate&apos;</string>
      <key>message</key>
      <string>Calling &apos;returnsRetainedCFDate&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1604</integer>
+      <key>line</key><integer>1620</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>2</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;returnsCFRetainedAsCF&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;returnsCFRetainedAsCF&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1604</integer>
+           <key>line</key><integer>1620</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1604</integer>
+           <key>line</key><integer>1620</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1606</integer>
+           <key>line</key><integer>1622</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1606</integer>
+           <key>line</key><integer>1622</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1606</integer>
+      <key>line</key><integer>1622</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1606</integer>
+         <key>line</key><integer>1622</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1606</integer>
+         <key>line</key><integer>1622</integer>
          <key>col</key><integer>52</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>2</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1615</integer>
+      <key>line</key><integer>1631</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1615</integer>
+         <key>line</key><integer>1631</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1615</integer>
+         <key>line</key><integer>1631</integer>
          <key>col</key><integer>32</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Returning from &apos;returnsRetainedCFDate&apos;</string>
      <key>message</key>
      <string>Returning from &apos;returnsRetainedCFDate&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1615</integer>
+           <key>line</key><integer>1631</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1615</integer>
+           <key>line</key><integer>1631</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1615</integer>
+           <key>line</key><integer>1631</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1615</integer>
+           <key>line</key><integer>1631</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1623</integer>
+      <key>line</key><integer>1639</integer>
       <key>col</key><integer>26</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1623</integer>
+         <key>line</key><integer>1639</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1623</integer>
+         <key>line</key><integer>1639</integer>
          <key>col</key><integer>53</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Returning from &apos;returnsCFRetainedAsCF&apos;</string>
      <key>message</key>
      <string>Returning from &apos;returnsCFRetainedAsCF&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1623</integer>
+           <key>line</key><integer>1639</integer>
            <key>col</key><integer>26</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1623</integer>
+           <key>line</key><integer>1639</integer>
            <key>col</key><integer>26</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1623</integer>
+           <key>line</key><integer>1639</integer>
            <key>col</key><integer>21</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1623</integer>
+           <key>line</key><integer>1639</integer>
            <key>col</key><integer>21</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1623</integer>
+      <key>line</key><integer>1639</integer>
       <key>col</key><integer>21</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1623</integer>
+         <key>line</key><integer>1639</integer>
          <key>col</key><integer>21</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1623</integer>
+         <key>line</key><integer>1639</integer>
          <key>col</key><integer>66</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>1623</integer>
+         <key>line</key><integer>1639</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1623</integer>
+         <key>line</key><integer>1639</integer>
          <key>col</key><integer>53</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object autoreleased</string>
      <key>message</key>
      <string>Object autoreleased</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1623</integer>
+           <key>line</key><integer>1639</integer>
            <key>col</key><integer>21</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1623</integer>
+           <key>line</key><integer>1639</integer>
            <key>col</key><integer>21</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1623</integer>
+           <key>line</key><integer>1639</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1623</integer>
+           <key>line</key><integer>1639</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1623</integer>
+      <key>line</key><integer>1639</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1623</integer>
+         <key>line</key><integer>1639</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1623</integer>
+         <key>line</key><integer>1639</integer>
          <key>col</key><integer>66</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object with a +0 retain count returned to caller where a +1 (owning) retain count is expected</string>
      <key>message</key>
      <string>Object with a +0 retain count returned to caller where a +1 (owning) retain count is expected</string>
     </dict>
    </array>
    <key>description</key><string>Object with a +0 retain count returned to caller where a +1 (owning) retain count is expected</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Method should return an owned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>2a609b8807dab6d3cb1a1db524094f2f</string>
   <key>issue_context_kind</key><string>Objective-C method</string>
   <key>issue_context</key><string>newCFRetainedAsCFNoAttr</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1623</integer>
+   <key>line</key><integer>1639</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1604</integer>
-    <integer>1605</integer>
-    <integer>1606</integer>
-    <integer>1614</integer>
-    <integer>1615</integer>
+    <integer>1620</integer>
+    <integer>1621</integer>
     <integer>1622</integer>
-    <integer>1623</integer>
+    <integer>1630</integer>
+    <integer>1631</integer>
+    <integer>1638</integer>
+    <integer>1639</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1627</integer>
+           <key>line</key><integer>1643</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1627</integer>
+           <key>line</key><integer>1643</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1627</integer>
+           <key>line</key><integer>1643</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1627</integer>
+           <key>line</key><integer>1643</integer>
            <key>col</key><integer>40</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1627</integer>
+      <key>line</key><integer>1643</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1627</integer>
+         <key>line</key><integer>1643</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1627</integer>
+         <key>line</key><integer>1643</integer>
          <key>col</key><integer>42</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling &apos;returnsRetainedCFDate&apos;</string>
      <key>message</key>
      <string>Calling &apos;returnsRetainedCFDate&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1604</integer>
+      <key>line</key><integer>1620</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;alsoReturnsRetained&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;alsoReturnsRetained&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1604</integer>
+           <key>line</key><integer>1620</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1604</integer>
+           <key>line</key><integer>1620</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1606</integer>
+           <key>line</key><integer>1622</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1606</integer>
+           <key>line</key><integer>1622</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1606</integer>
+      <key>line</key><integer>1622</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1606</integer>
+         <key>line</key><integer>1622</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1606</integer>
+         <key>line</key><integer>1622</integer>
          <key>col</key><integer>52</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1627</integer>
+      <key>line</key><integer>1643</integer>
       <key>col</key><integer>20</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1627</integer>
+         <key>line</key><integer>1643</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1627</integer>
+         <key>line</key><integer>1643</integer>
          <key>col</key><integer>42</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Returning from &apos;returnsRetainedCFDate&apos;</string>
      <key>message</key>
      <string>Returning from &apos;returnsRetainedCFDate&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1627</integer>
+           <key>line</key><integer>1643</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1627</integer>
+           <key>line</key><integer>1643</integer>
            <key>col</key><integer>40</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1627</integer>
+           <key>line</key><integer>1643</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1627</integer>
+           <key>line</key><integer>1643</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1627</integer>
+      <key>line</key><integer>1643</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1627</integer>
+         <key>line</key><integer>1643</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1627</integer>
+         <key>line</key><integer>1643</integer>
          <key>col</key><integer>42</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CFDateRef&apos; is returned from a method whose name (&apos;alsoReturnsRetained&apos;) does not start with &apos;copy&apos;, &apos;mutableCopy&apos;, &apos;alloc&apos; or &apos;new&apos;.  This violates the naming convention rules given in the Memory Management Guide for Cocoa</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CFDateRef&apos; is returned from a method whose name (&apos;alsoReturnsRetained&apos;) does not start with &apos;copy&apos;, &apos;mutableCopy&apos;, &apos;alloc&apos; or &apos;new&apos;.  This violates the naming convention rules given in the Memory Management Guide for Cocoa</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CFDateRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak of returned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>944f189da47b1406f9cca6f17ad9f77c</string>
   <key>issue_context_kind</key><string>Objective-C method</string>
   <key>issue_context</key><string>alsoReturnsRetained</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1627</integer>
+   <key>line</key><integer>1643</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1604</integer>
-    <integer>1605</integer>
-    <integer>1606</integer>
-    <integer>1626</integer>
-    <integer>1627</integer>
+    <integer>1620</integer>
+    <integer>1621</integer>
+    <integer>1622</integer>
+    <integer>1642</integer>
+    <integer>1643</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1631</integer>
+           <key>line</key><integer>1647</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1631</integer>
+           <key>line</key><integer>1647</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1631</integer>
+           <key>line</key><integer>1647</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1631</integer>
+           <key>line</key><integer>1647</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1631</integer>
+      <key>line</key><integer>1647</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1631</integer>
+         <key>line</key><integer>1647</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1631</integer>
+         <key>line</key><integer>1647</integer>
          <key>col</key><integer>32</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling &apos;returnsRetainedCFDate&apos;</string>
      <key>message</key>
      <string>Calling &apos;returnsRetainedCFDate&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1604</integer>
+      <key>line</key><integer>1620</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;alsoReturnsRetainedAsCF&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;alsoReturnsRetainedAsCF&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1604</integer>
+           <key>line</key><integer>1620</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1604</integer>
+           <key>line</key><integer>1620</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1606</integer>
+           <key>line</key><integer>1622</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1606</integer>
+           <key>line</key><integer>1622</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1606</integer>
+      <key>line</key><integer>1622</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1606</integer>
+         <key>line</key><integer>1622</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1606</integer>
+         <key>line</key><integer>1622</integer>
          <key>col</key><integer>52</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1631</integer>
+      <key>line</key><integer>1647</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1631</integer>
+         <key>line</key><integer>1647</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1631</integer>
+         <key>line</key><integer>1647</integer>
          <key>col</key><integer>32</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Returning from &apos;returnsRetainedCFDate&apos;</string>
      <key>message</key>
      <string>Returning from &apos;returnsRetainedCFDate&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1631</integer>
+           <key>line</key><integer>1647</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1631</integer>
+           <key>line</key><integer>1647</integer>
            <key>col</key><integer>30</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1631</integer>
+           <key>line</key><integer>1647</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1631</integer>
+           <key>line</key><integer>1647</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1631</integer>
+      <key>line</key><integer>1647</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1631</integer>
+         <key>line</key><integer>1647</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1631</integer>
+         <key>line</key><integer>1647</integer>
          <key>col</key><integer>32</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CFDateRef&apos; is returned from a method whose name (&apos;alsoReturnsRetainedAsCF&apos;) does not start with &apos;copy&apos;, &apos;mutableCopy&apos;, &apos;alloc&apos; or &apos;new&apos;.  This violates the naming convention rules given in the Memory Management Guide for Cocoa</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CFDateRef&apos; is returned from a method whose name (&apos;alsoReturnsRetainedAsCF&apos;) does not start with &apos;copy&apos;, &apos;mutableCopy&apos;, &apos;alloc&apos; or &apos;new&apos;.  This violates the naming convention rules given in the Memory Management Guide for Cocoa</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CFDateRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak of returned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>30ebf65449c31336f8a97555d79f1943</string>
   <key>issue_context_kind</key><string>Objective-C method</string>
   <key>issue_context</key><string>alsoReturnsRetainedAsCF</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1631</integer>
+   <key>line</key><integer>1647</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1604</integer>
-    <integer>1605</integer>
-    <integer>1606</integer>
-    <integer>1630</integer>
-    <integer>1631</integer>
+    <integer>1620</integer>
+    <integer>1621</integer>
+    <integer>1622</integer>
+    <integer>1646</integer>
+    <integer>1647</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1651</integer>
+           <key>line</key><integer>1667</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1651</integer>
+           <key>line</key><integer>1667</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1652</integer>
+           <key>line</key><integer>1668</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1652</integer>
+           <key>line</key><integer>1668</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1652</integer>
+      <key>line</key><integer>1668</integer>
       <key>col</key><integer>23</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1652</integer>
+         <key>line</key><integer>1668</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1652</integer>
+         <key>line</key><integer>1668</integer>
          <key>col</key><integer>82</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFNumberCreate&apos; returns a Core Foundation object of type &apos;CFNumberRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFNumberCreate&apos; returns a Core Foundation object of type &apos;CFNumberRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1652</integer>
+           <key>line</key><integer>1668</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1652</integer>
+           <key>line</key><integer>1668</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1653</integer>
+           <key>line</key><integer>1669</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1653</integer>
+           <key>line</key><integer>1669</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1653</integer>
+      <key>line</key><integer>1669</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;value&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;value&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;value&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>2ab1a2345ddfa1fd48777c7c179d4e33</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_panic_negative</string>
   <key>issue_hash_function_offset</key><string>2</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1653</integer>
+   <key>line</key><integer>1669</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1650</integer>
-    <integer>1651</integer>
-    <integer>1652</integer>
-    <integer>1653</integer>
+    <integer>1666</integer>
+    <integer>1667</integer>
+    <integer>1668</integer>
+    <integer>1669</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1662</integer>
+           <key>line</key><integer>1678</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1662</integer>
+           <key>line</key><integer>1678</integer>
            <key>col</key><integer>8</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1663</integer>
+           <key>line</key><integer>1679</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1663</integer>
+           <key>line</key><integer>1679</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1663</integer>
+      <key>line</key><integer>1679</integer>
       <key>col</key><integer>23</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1663</integer>
+         <key>line</key><integer>1679</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1663</integer>
+         <key>line</key><integer>1679</integer>
          <key>col</key><integer>82</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFNumberCreate&apos; returns a Core Foundation object of type &apos;CFNumberRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFNumberCreate&apos; returns a Core Foundation object of type &apos;CFNumberRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1663</integer>
+           <key>line</key><integer>1679</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1663</integer>
+           <key>line</key><integer>1679</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1664</integer>
+           <key>line</key><integer>1680</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1664</integer>
+           <key>line</key><integer>1680</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1664</integer>
+           <key>line</key><integer>1680</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1664</integer>
+           <key>line</key><integer>1680</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1664</integer>
+           <key>line</key><integer>1680</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1664</integer>
+           <key>line</key><integer>1680</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1664</integer>
+      <key>line</key><integer>1680</integer>
       <key>col</key><integer>7</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1664</integer>
+         <key>line</key><integer>1680</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1664</integer>
+         <key>line</key><integer>1680</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;x&apos; is 0</string>
      <key>message</key>
      <string>Assuming &apos;x&apos; is 0</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1664</integer>
+           <key>line</key><integer>1680</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1664</integer>
+           <key>line</key><integer>1680</integer>
            <key>col</key><integer>7</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1666</integer>
+           <key>line</key><integer>1682</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1666</integer>
+           <key>line</key><integer>1682</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1666</integer>
+      <key>line</key><integer>1682</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;value&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;value&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;value&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>f96bb4f5c1af6cf932d7ab58b678c235</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_panic_neg_2</string>
   <key>issue_hash_function_offset</key><string>2</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1666</integer>
+   <key>line</key><integer>1682</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1661</integer>
-    <integer>1662</integer>
-    <integer>1663</integer>
-    <integer>1664</integer>
-    <integer>1666</integer>
+    <integer>1677</integer>
+    <integer>1678</integer>
+    <integer>1679</integer>
+    <integer>1680</integer>
+    <integer>1682</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1686</integer>
+      <key>line</key><integer>1702</integer>
       <key>col</key><integer>22</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1686</integer>
+         <key>line</key><integer>1702</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1686</integer>
+         <key>line</key><integer>1702</integer>
          <key>col</key><integer>53</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSNumber with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSNumber with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1686</integer>
+           <key>line</key><integer>1702</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1686</integer>
+           <key>line</key><integer>1702</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1687</integer>
+           <key>line</key><integer>1703</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1687</integer>
+           <key>line</key><integer>1703</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1687</integer>
+      <key>line</key><integer>1703</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1687</integer>
+         <key>line</key><integer>1703</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1687</integer>
+         <key>line</key><integer>1703</integer>
          <key>col</key><integer>7</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;number&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;number&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;number&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>14182fb28ed03595f896c2f8536ac111</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_blocks_1_pos</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1687</integer>
+   <key>line</key><integer>1703</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1685</integer>
-    <integer>1686</integer>
-    <integer>1687</integer>
+    <integer>1701</integer>
+    <integer>1702</integer>
+    <integer>1703</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1707</integer>
+      <key>line</key><integer>1723</integer>
       <key>col</key><integer>22</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1707</integer>
+         <key>line</key><integer>1723</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1707</integer>
+         <key>line</key><integer>1723</integer>
          <key>col</key><integer>53</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSNumber with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSNumber with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1707</integer>
+           <key>line</key><integer>1723</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1707</integer>
+           <key>line</key><integer>1723</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1708</integer>
+           <key>line</key><integer>1724</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1708</integer>
+           <key>line</key><integer>1724</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1708</integer>
+      <key>line</key><integer>1724</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1708</integer>
+         <key>line</key><integer>1724</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1708</integer>
+         <key>line</key><integer>1724</integer>
          <key>col</key><integer>39</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Calling anonymous block</string>
      <key>message</key>
      <string>Calling anonymous block</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1708</integer>
+      <key>line</key><integer>1724</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Entered call from &apos;test_blocks_1_indirect_retain_via_call&apos;</string>
      <key>message</key>
      <string>Entered call from &apos;test_blocks_1_indirect_retain_via_call&apos;</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1708</integer>
+           <key>line</key><integer>1724</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1708</integer>
+           <key>line</key><integer>1724</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1708</integer>
+           <key>line</key><integer>1724</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1708</integer>
+           <key>line</key><integer>1724</integer>
            <key>col</key><integer>19</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1708</integer>
+      <key>line</key><integer>1724</integer>
       <key>col</key><integer>19</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1708</integer>
+         <key>line</key><integer>1724</integer>
          <key>col</key><integer>19</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1708</integer>
+         <key>line</key><integer>1724</integer>
          <key>col</key><integer>28</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>1708</integer>
+         <key>line</key><integer>1724</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1708</integer>
+         <key>line</key><integer>1724</integer>
          <key>col</key><integer>20</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>1</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +2 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +2 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1708</integer>
+      <key>line</key><integer>1724</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1708</integer>
+         <key>line</key><integer>1724</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1708</integer>
+         <key>line</key><integer>1724</integer>
          <key>col</key><integer>39</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Returning to caller</string>
      <key>message</key>
      <string>Returning to caller</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1708</integer>
+           <key>line</key><integer>1724</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1708</integer>
+           <key>line</key><integer>1724</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1709</integer>
+           <key>line</key><integer>1725</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1709</integer>
+           <key>line</key><integer>1725</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1709</integer>
+      <key>line</key><integer>1725</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;number&apos; is not referenced later in this execution path and has a retain count of +2</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;number&apos; is not referenced later in this execution path and has a retain count of +2</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;number&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>dbf800f836ff675d2f779f7417877c1b</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_blocks_1_indirect_retain_via_call</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1709</integer>
+   <key>line</key><integer>1725</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1706</integer>
-    <integer>1707</integer>
-    <integer>1708</integer>
-    <integer>1709</integer>
+    <integer>1722</integer>
+    <integer>1723</integer>
+    <integer>1724</integer>
+    <integer>1725</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1759</integer>
+           <key>line</key><integer>1775</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1759</integer>
+           <key>line</key><integer>1775</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1762</integer>
+           <key>line</key><integer>1778</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1762</integer>
+           <key>line</key><integer>1778</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1762</integer>
+           <key>line</key><integer>1778</integer>
            <key>col</key><integer>5</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1762</integer>
+           <key>line</key><integer>1778</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1762</integer>
+           <key>line</key><integer>1778</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1762</integer>
+           <key>line</key><integer>1778</integer>
            <key>col</key><integer>24</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1762</integer>
+      <key>line</key><integer>1778</integer>
       <key>col</key><integer>12</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1762</integer>
+         <key>line</key><integer>1778</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1762</integer>
+         <key>line</key><integer>1778</integer>
          <key>col</key><integer>38</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;error_to_dump&apos; is not equal to null</string>
      <key>message</key>
      <string>Assuming &apos;error_to_dump&apos; is not equal to null</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1762</integer>
+      <key>line</key><integer>1778</integer>
       <key>col</key><integer>12</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1762</integer>
+         <key>line</key><integer>1778</integer>
          <key>col</key><integer>12</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1762</integer>
+         <key>line</key><integer>1778</integer>
          <key>col</key><integer>38</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Entering loop body</string>
      <key>message</key>
      <string>Entering loop body</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1762</integer>
+           <key>line</key><integer>1778</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1762</integer>
+           <key>line</key><integer>1778</integer>
            <key>col</key><integer>24</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1763</integer>
+           <key>line</key><integer>1779</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1763</integer>
+           <key>line</key><integer>1779</integer>
            <key>col</key><integer>23</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1763</integer>
+           <key>line</key><integer>1779</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1763</integer>
+           <key>line</key><integer>1779</integer>
            <key>col</key><integer>23</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1765</integer>
+           <key>line</key><integer>1781</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1765</integer>
+           <key>line</key><integer>1781</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1765</integer>
+      <key>line</key><integer>1781</integer>
       <key>col</key><integer>16</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1765</integer>
+         <key>line</key><integer>1781</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1765</integer>
+         <key>line</key><integer>1781</integer>
          <key>col</key><integer>49</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFErrorCopyUserInfo&apos; returns a Core Foundation object of type &apos;CFDictionaryRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFErrorCopyUserInfo&apos; returns a Core Foundation object of type &apos;CFDictionaryRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1765</integer>
+           <key>line</key><integer>1781</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1765</integer>
+           <key>line</key><integer>1781</integer>
            <key>col</key><integer>12</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1767</integer>
+           <key>line</key><integer>1783</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1767</integer>
+           <key>line</key><integer>1783</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1767</integer>
+           <key>line</key><integer>1783</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1767</integer>
+           <key>line</key><integer>1783</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1767</integer>
+           <key>line</key><integer>1783</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1767</integer>
+           <key>line</key><integer>1783</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1767</integer>
+      <key>line</key><integer>1783</integer>
       <key>col</key><integer>13</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1767</integer>
+         <key>line</key><integer>1783</integer>
          <key>col</key><integer>13</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1767</integer>
+         <key>line</key><integer>1783</integer>
          <key>col</key><integer>30</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Assuming &apos;info&apos; is not equal to null</string>
      <key>message</key>
      <string>Assuming &apos;info&apos; is not equal to null</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1767</integer>
+           <key>line</key><integer>1783</integer>
            <key>col</key><integer>13</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1767</integer>
+           <key>line</key><integer>1783</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1770</integer>
+           <key>line</key><integer>1786</integer>
            <key>col</key><integer>23</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1770</integer>
+           <key>line</key><integer>1786</integer>
            <key>col</key><integer>23</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1770</integer>
+      <key>line</key><integer>1786</integer>
       <key>col</key><integer>23</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;info&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;info&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;info&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>64424de797303506a3dfdb52fa765645</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar_8724287</string>
   <key>issue_hash_function_offset</key><string>7</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1770</integer>
+   <key>line</key><integer>1786</integer>
    <key>col</key><integer>23</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1757</integer>
-    <integer>1758</integer>
-    <integer>1759</integer>
-    <integer>1761</integer>
-    <integer>1762</integer>
-    <integer>1763</integer>
-    <integer>1765</integer>
-    <integer>1767</integer>
-    <integer>1770</integer>
+    <integer>1773</integer>
+    <integer>1774</integer>
+    <integer>1775</integer>
+    <integer>1777</integer>
+    <integer>1778</integer>
+    <integer>1779</integer>
+    <integer>1781</integer>
+    <integer>1783</integer>
+    <integer>1786</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1815</integer>
+      <key>line</key><integer>1831</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1815</integer>
+         <key>line</key><integer>1831</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1815</integer>
+         <key>line</key><integer>1831</integer>
          <key>col</key><integer>60</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1815</integer>
+      <key>line</key><integer>1831</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1815</integer>
+         <key>line</key><integer>1831</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1815</integer>
+         <key>line</key><integer>1831</integer>
          <key>col</key><integer>60</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableArrayRef&apos; is returned from a function whose name (&apos;camelcase_createno&apos;) does not contain &apos;Copy&apos; or &apos;Create&apos;.  This violates the naming convention rules given in the Memory Management Guide for Core Foundation</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableArrayRef&apos; is returned from a function whose name (&apos;camelcase_createno&apos;) does not contain &apos;Copy&apos; or &apos;Create&apos;.  This violates the naming convention rules given in the Memory Management Guide for Core Foundation</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CFMutableArrayRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak of returned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>7b7fc0c36e58713202141cb584150903</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>camelcase_createno</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1815</integer>
+   <key>line</key><integer>1831</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1814</integer>
-    <integer>1815</integer>
+    <integer>1830</integer>
+    <integer>1831</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1823</integer>
+      <key>line</key><integer>1839</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1823</integer>
+         <key>line</key><integer>1839</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1823</integer>
+         <key>line</key><integer>1839</integer>
          <key>col</key><integer>60</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1823</integer>
+      <key>line</key><integer>1839</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1823</integer>
+         <key>line</key><integer>1839</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1823</integer>
+         <key>line</key><integer>1839</integer>
          <key>col</key><integer>60</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableArrayRef&apos; is returned from a function whose name (&apos;camelcase_copying&apos;) does not contain &apos;Copy&apos; or &apos;Create&apos;.  This violates the naming convention rules given in the Memory Management Guide for Core Foundation</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableArrayRef&apos; is returned from a function whose name (&apos;camelcase_copying&apos;) does not contain &apos;Copy&apos; or &apos;Create&apos;.  This violates the naming convention rules given in the Memory Management Guide for Core Foundation</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CFMutableArrayRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak of returned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>32912dd9518de1b3f4cc8ba38368f7e6</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>camelcase_copying</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1823</integer>
+   <key>line</key><integer>1839</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1822</integer>
-    <integer>1823</integer>
+    <integer>1838</integer>
+    <integer>1839</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1844</integer>
+      <key>line</key><integer>1860</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1844</integer>
+         <key>line</key><integer>1860</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1844</integer>
+         <key>line</key><integer>1860</integer>
          <key>col</key><integer>60</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1844</integer>
+      <key>line</key><integer>1860</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1844</integer>
+         <key>line</key><integer>1860</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1844</integer>
+         <key>line</key><integer>1860</integer>
          <key>col</key><integer>60</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableArrayRef&apos; is returned from a function whose name (&apos;camel_creat&apos;) does not contain &apos;Copy&apos; or &apos;Create&apos;.  This violates the naming convention rules given in the Memory Management Guide for Core Foundation</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableArrayRef&apos; is returned from a function whose name (&apos;camel_creat&apos;) does not contain &apos;Copy&apos; or &apos;Create&apos;.  This violates the naming convention rules given in the Memory Management Guide for Core Foundation</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CFMutableArrayRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak of returned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>1dccc42846a9ef9bf1a1830e277d5b78</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>camel_creat</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1844</integer>
+   <key>line</key><integer>1860</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1843</integer>
-    <integer>1844</integer>
+    <integer>1859</integer>
+    <integer>1860</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1856</integer>
+      <key>line</key><integer>1872</integer>
       <key>col</key><integer>10</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1856</integer>
+         <key>line</key><integer>1872</integer>
          <key>col</key><integer>10</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1856</integer>
+         <key>line</key><integer>1872</integer>
          <key>col</key><integer>60</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFArrayCreateMutable&apos; returns a Core Foundation object of type &apos;CFMutableArrayRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1856</integer>
+      <key>line</key><integer>1872</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1856</integer>
+         <key>line</key><integer>1872</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1856</integer>
+         <key>line</key><integer>1872</integer>
          <key>col</key><integer>60</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableArrayRef&apos; is returned from a function whose name (&apos;camel_copymachine&apos;) does not contain &apos;Copy&apos; or &apos;Create&apos;.  This violates the naming convention rules given in the Memory Management Guide for Core Foundation</string>
      <key>message</key>
      <string>Object leaked: allocated object of type &apos;CFMutableArrayRef&apos; is returned from a function whose name (&apos;camel_copymachine&apos;) does not contain &apos;Copy&apos; or &apos;Create&apos;.  This violates the naming convention rules given in the Memory Management Guide for Core Foundation</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object of type &apos;CFMutableArrayRef&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak of returned object</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>2a0ba33097f6e9362a79689e2ac0cf4a</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>camel_copymachine</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1856</integer>
+   <key>line</key><integer>1872</integer>
    <key>col</key><integer>3</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1855</integer>
-    <integer>1856</integer>
+    <integer>1871</integer>
+    <integer>1872</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1876</integer>
+           <key>line</key><integer>1892</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1876</integer>
+           <key>line</key><integer>1892</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1877</integer>
+           <key>line</key><integer>1893</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1877</integer>
+           <key>line</key><integer>1893</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1877</integer>
+      <key>line</key><integer>1893</integer>
       <key>col</key><integer>24</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1877</integer>
+         <key>line</key><integer>1893</integer>
          <key>col</key><integer>24</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1877</integer>
+         <key>line</key><integer>1893</integer>
          <key>col</key><integer>41</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
      <key>message</key>
      <string>Call to function &apos;CFDateCreate&apos; returns a Core Foundation object of type &apos;CFDateRef&apos; with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1877</integer>
+           <key>line</key><integer>1893</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1877</integer>
+           <key>line</key><integer>1893</integer>
            <key>col</key><integer>11</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1878</integer>
+           <key>line</key><integer>1894</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1878</integer>
+           <key>line</key><integer>1894</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1878</integer>
+      <key>line</key><integer>1894</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;vals&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;vals&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;vals&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>43f6c1be372d09a4a4cffaefa69d0148</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar6582778</string>
   <key>issue_hash_function_offset</key><string>2</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1878</integer>
+   <key>line</key><integer>1894</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1875</integer>
-    <integer>1876</integer>
-    <integer>1877</integer>
-    <integer>1878</integer>
+    <integer>1891</integer>
+    <integer>1892</integer>
+    <integer>1893</integer>
+    <integer>1894</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1902</integer>
+           <key>line</key><integer>1918</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1902</integer>
+           <key>line</key><integer>1918</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1904</integer>
+           <key>line</key><integer>1920</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1904</integer>
+           <key>line</key><integer>1920</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1904</integer>
+      <key>line</key><integer>1920</integer>
       <key>col</key><integer>22</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1904</integer>
+         <key>line</key><integer>1920</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1904</integer>
+         <key>line</key><integer>1920</integer>
          <key>col</key><integer>64</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSString with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1904</integer>
+           <key>line</key><integer>1920</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1904</integer>
+           <key>line</key><integer>1920</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1905</integer>
+           <key>line</key><integer>1921</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1905</integer>
+           <key>line</key><integer>1921</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1905</integer>
+      <key>line</key><integer>1921</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1905</integer>
+         <key>line</key><integer>1921</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1905</integer>
+         <key>line</key><integer>1921</integer>
          <key>col</key><integer>18</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>1905</integer>
+         <key>line</key><integer>1921</integer>
          <key>col</key><integer>4</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1905</integer>
+         <key>line</key><integer>1921</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object released</string>
      <key>message</key>
      <string>Object released</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1905</integer>
+           <key>line</key><integer>1921</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1905</integer>
+           <key>line</key><integer>1921</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1907</integer>
+           <key>line</key><integer>1923</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1907</integer>
+           <key>line</key><integer>1923</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>1907</integer>
+           <key>line</key><integer>1923</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1907</integer>
+           <key>line</key><integer>1923</integer>
            <key>col</key><integer>10</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>1907</integer>
+           <key>line</key><integer>1923</integer>
            <key>col</key><integer>27</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>1907</integer>
+           <key>line</key><integer>1923</integer>
            <key>col</key><integer>27</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>1907</integer>
+      <key>line</key><integer>1923</integer>
       <key>col</key><integer>27</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>1907</integer>
+         <key>line</key><integer>1923</integer>
          <key>col</key><integer>28</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>1907</integer>
+         <key>line</key><integer>1923</integer>
          <key>col</key><integer>33</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference-counted object is used after it is released</string>
      <key>message</key>
      <string>Reference-counted object is used after it is released</string>
     </dict>
    </array>
    <key>description</key><string>Reference-counted object is used after it is released</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Use-after-release</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>ebe7e868c0075bfa7480e3359e4fbce8</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>rdar10232019_positive</string>
   <key>issue_hash_function_offset</key><string>6</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>1907</integer>
+   <key>line</key><integer>1923</integer>
    <key>col</key><integer>27</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>1901</integer>
-    <integer>1902</integer>
-    <integer>1904</integer>
-    <integer>1905</integer>
-    <integer>1907</integer>
+    <integer>1917</integer>
+    <integer>1918</integer>
+    <integer>1920</integer>
+    <integer>1921</integer>
+    <integer>1923</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2034</integer>
+           <key>line</key><integer>2050</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2034</integer>
+           <key>line</key><integer>2050</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2035</integer>
+           <key>line</key><integer>2051</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2035</integer>
+           <key>line</key><integer>2051</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2035</integer>
+      <key>line</key><integer>2051</integer>
       <key>col</key><integer>22</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2035</integer>
+         <key>line</key><integer>2051</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2035</integer>
+         <key>line</key><integer>2051</integer>
          <key>col</key><integer>66</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSArray with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSArray with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2035</integer>
+           <key>line</key><integer>2051</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2035</integer>
+           <key>line</key><integer>2051</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2038</integer>
+      <key>line</key><integer>2054</integer>
       <key>col</key><integer>9</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2038</integer>
+         <key>line</key><integer>2054</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2038</integer>
+         <key>line</key><integer>2054</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;a&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;a&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;a&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>507c3679ae27249e01844b7555843688</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_objc_arrays</string>
   <key>issue_hash_function_offset</key><string>3</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>2038</integer>
+   <key>line</key><integer>2054</integer>
    <key>col</key><integer>9</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>2032</integer>
-    <integer>2034</integer>
-    <integer>2035</integer>
-    <integer>2036</integer>
-    <integer>2037</integer>
-    <integer>2038</integer>
+    <integer>2048</integer>
+    <integer>2050</integer>
+    <integer>2051</integer>
+    <integer>2052</integer>
+    <integer>2053</integer>
+    <integer>2054</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2034</integer>
+           <key>line</key><integer>2050</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2034</integer>
+           <key>line</key><integer>2050</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2044</integer>
+           <key>line</key><integer>2060</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2044</integer>
+           <key>line</key><integer>2060</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2044</integer>
+      <key>line</key><integer>2060</integer>
       <key>col</key><integer>23</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2044</integer>
+         <key>line</key><integer>2060</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2044</integer>
+         <key>line</key><integer>2060</integer>
          <key>col</key><integer>56</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSArray with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSArray with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2044</integer>
+           <key>line</key><integer>2060</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2044</integer>
+           <key>line</key><integer>2060</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2047</integer>
+      <key>line</key><integer>2063</integer>
       <key>col</key><integer>9</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2047</integer>
+         <key>line</key><integer>2063</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2047</integer>
+         <key>line</key><integer>2063</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;a2&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;a2&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;a2&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>821f8268a0b7d3f90e4dd88fa1edf39b</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_objc_arrays</string>
   <key>issue_hash_function_offset</key><string>12</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>2047</integer>
+   <key>line</key><integer>2063</integer>
    <key>col</key><integer>9</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>2032</integer>
-    <integer>2034</integer>
-    <integer>2035</integer>
-    <integer>2036</integer>
-    <integer>2037</integer>
-    <integer>2038</integer>
-    <integer>2042</integer>
-    <integer>2043</integer>
-    <integer>2044</integer>
-    <integer>2045</integer>
-    <integer>2046</integer>
-    <integer>2047</integer>
+    <integer>2048</integer>
+    <integer>2050</integer>
+    <integer>2051</integer>
+    <integer>2052</integer>
+    <integer>2053</integer>
+    <integer>2054</integer>
+    <integer>2058</integer>
+    <integer>2059</integer>
+    <integer>2060</integer>
+    <integer>2061</integer>
+    <integer>2062</integer>
+    <integer>2063</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2034</integer>
+           <key>line</key><integer>2050</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2034</integer>
+           <key>line</key><integer>2050</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2051</integer>
+           <key>line</key><integer>2067</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2051</integer>
+           <key>line</key><integer>2067</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2051</integer>
+           <key>line</key><integer>2067</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2051</integer>
+           <key>line</key><integer>2067</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2052</integer>
+           <key>line</key><integer>2068</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2052</integer>
+           <key>line</key><integer>2068</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2052</integer>
+           <key>line</key><integer>2068</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2052</integer>
+           <key>line</key><integer>2068</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2052</integer>
+           <key>line</key><integer>2068</integer>
            <key>col</key><integer>24</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2052</integer>
+           <key>line</key><integer>2068</integer>
            <key>col</key><integer>24</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2052</integer>
+      <key>line</key><integer>2068</integer>
       <key>col</key><integer>24</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2052</integer>
+         <key>line</key><integer>2068</integer>
          <key>col</key><integer>24</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2052</integer>
+         <key>line</key><integer>2068</integer>
          <key>col</key><integer>27</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>NSArray literal is an object with a +0 retain count</string>
      <key>message</key>
      <string>NSArray literal is an object with a +0 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2052</integer>
+      <key>line</key><integer>2068</integer>
       <key>col</key><integer>23</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2052</integer>
+         <key>line</key><integer>2068</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2052</integer>
+         <key>line</key><integer>2068</integer>
          <key>col</key><integer>35</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>2052</integer>
+         <key>line</key><integer>2068</integer>
          <key>col</key><integer>24</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2052</integer>
+         <key>line</key><integer>2068</integer>
          <key>col</key><integer>27</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2052</integer>
+           <key>line</key><integer>2068</integer>
            <key>col</key><integer>23</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2052</integer>
+           <key>line</key><integer>2068</integer>
            <key>col</key><integer>23</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2052</integer>
+           <key>line</key><integer>2068</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2052</integer>
+           <key>line</key><integer>2068</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2052</integer>
+           <key>line</key><integer>2068</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2052</integer>
+           <key>line</key><integer>2068</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2055</integer>
+           <key>line</key><integer>2071</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2055</integer>
+           <key>line</key><integer>2071</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2055</integer>
+      <key>line</key><integer>2071</integer>
       <key>col</key><integer>9</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2055</integer>
+         <key>line</key><integer>2071</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2055</integer>
+         <key>line</key><integer>2071</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;a3&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;a3&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;a3&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>37b00e6e0e6b792ea3294a9ffd6f4886</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_objc_arrays</string>
   <key>issue_hash_function_offset</key><string>20</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>2055</integer>
+   <key>line</key><integer>2071</integer>
    <key>col</key><integer>9</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>2032</integer>
-    <integer>2034</integer>
-    <integer>2035</integer>
-    <integer>2036</integer>
-    <integer>2037</integer>
-    <integer>2038</integer>
-    <integer>2042</integer>
-    <integer>2043</integer>
-    <integer>2044</integer>
-    <integer>2045</integer>
-    <integer>2046</integer>
-    <integer>2047</integer>
+    <integer>2048</integer>
+    <integer>2050</integer>
     <integer>2051</integer>
     <integer>2052</integer>
     <integer>2053</integer>
     <integer>2054</integer>
-    <integer>2055</integer>
+    <integer>2058</integer>
+    <integer>2059</integer>
+    <integer>2060</integer>
+    <integer>2061</integer>
+    <integer>2062</integer>
+    <integer>2063</integer>
+    <integer>2067</integer>
+    <integer>2068</integer>
+    <integer>2069</integer>
+    <integer>2070</integer>
+    <integer>2071</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2034</integer>
+           <key>line</key><integer>2050</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2034</integer>
+           <key>line</key><integer>2050</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2051</integer>
+           <key>line</key><integer>2067</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2051</integer>
+           <key>line</key><integer>2067</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2051</integer>
+           <key>line</key><integer>2067</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2051</integer>
+           <key>line</key><integer>2067</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2055</integer>
+           <key>line</key><integer>2071</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2055</integer>
+           <key>line</key><integer>2071</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2055</integer>
+           <key>line</key><integer>2071</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2055</integer>
+           <key>line</key><integer>2071</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2059</integer>
+           <key>line</key><integer>2075</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2059</integer>
+           <key>line</key><integer>2075</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2059</integer>
+           <key>line</key><integer>2075</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2059</integer>
+           <key>line</key><integer>2075</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2060</integer>
+           <key>line</key><integer>2076</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2060</integer>
+           <key>line</key><integer>2076</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2060</integer>
+      <key>line</key><integer>2076</integer>
       <key>col</key><integer>22</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2060</integer>
+         <key>line</key><integer>2076</integer>
          <key>col</key><integer>22</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2060</integer>
+         <key>line</key><integer>2076</integer>
          <key>col</key><integer>57</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Method returns an instance of NSArray with a +1 retain count</string>
      <key>message</key>
      <string>Method returns an instance of NSArray with a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2060</integer>
+           <key>line</key><integer>2076</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2060</integer>
+           <key>line</key><integer>2076</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2064</integer>
+           <key>line</key><integer>2080</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2064</integer>
+           <key>line</key><integer>2080</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2064</integer>
+      <key>line</key><integer>2080</integer>
       <key>col</key><integer>9</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2064</integer>
+         <key>line</key><integer>2080</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2064</integer>
+         <key>line</key><integer>2080</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;a&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;a&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;a&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>62fc5b80705a03ab1d8b50bdcfbfb179</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_objc_arrays</string>
   <key>issue_hash_function_offset</key><string>28</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>2064</integer>
+   <key>line</key><integer>2080</integer>
    <key>col</key><integer>9</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>2032</integer>
-    <integer>2034</integer>
-    <integer>2035</integer>
-    <integer>2036</integer>
-    <integer>2037</integer>
-    <integer>2038</integer>
-    <integer>2042</integer>
-    <integer>2043</integer>
-    <integer>2044</integer>
-    <integer>2045</integer>
-    <integer>2046</integer>
-    <integer>2047</integer>
+    <integer>2048</integer>
+    <integer>2050</integer>
     <integer>2051</integer>
     <integer>2052</integer>
     <integer>2053</integer>
     <integer>2054</integer>
-    <integer>2055</integer>
+    <integer>2058</integer>
     <integer>2059</integer>
     <integer>2060</integer>
     <integer>2061</integer>
+    <integer>2062</integer>
     <integer>2063</integer>
-    <integer>2064</integer>
+    <integer>2067</integer>
+    <integer>2068</integer>
+    <integer>2069</integer>
+    <integer>2070</integer>
+    <integer>2071</integer>
+    <integer>2075</integer>
+    <integer>2076</integer>
+    <integer>2077</integer>
+    <integer>2079</integer>
+    <integer>2080</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2034</integer>
+           <key>line</key><integer>2050</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2034</integer>
+           <key>line</key><integer>2050</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2038</integer>
+           <key>line</key><integer>2054</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2042</integer>
+           <key>line</key><integer>2058</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2047</integer>
+           <key>line</key><integer>2063</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2051</integer>
+           <key>line</key><integer>2067</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2051</integer>
+           <key>line</key><integer>2067</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2051</integer>
+           <key>line</key><integer>2067</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2051</integer>
+           <key>line</key><integer>2067</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2055</integer>
+           <key>line</key><integer>2071</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2055</integer>
+           <key>line</key><integer>2071</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2055</integer>
+           <key>line</key><integer>2071</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2055</integer>
+           <key>line</key><integer>2071</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2059</integer>
+           <key>line</key><integer>2075</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2059</integer>
+           <key>line</key><integer>2075</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2059</integer>
+           <key>line</key><integer>2075</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2059</integer>
+           <key>line</key><integer>2075</integer>
            <key>col</key><integer>16</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2064</integer>
+           <key>line</key><integer>2080</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2064</integer>
+           <key>line</key><integer>2080</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2064</integer>
+           <key>line</key><integer>2080</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2064</integer>
+           <key>line</key><integer>2080</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2068</integer>
+           <key>line</key><integer>2084</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2068</integer>
+           <key>line</key><integer>2084</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2068</integer>
+           <key>line</key><integer>2084</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2068</integer>
+           <key>line</key><integer>2084</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2069</integer>
+           <key>line</key><integer>2085</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2069</integer>
+           <key>line</key><integer>2085</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2069</integer>
+           <key>line</key><integer>2085</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2069</integer>
+           <key>line</key><integer>2085</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2069</integer>
+           <key>line</key><integer>2085</integer>
            <key>col</key><integer>28</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2069</integer>
+           <key>line</key><integer>2085</integer>
            <key>col</key><integer>28</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2069</integer>
+      <key>line</key><integer>2085</integer>
       <key>col</key><integer>28</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2069</integer>
+         <key>line</key><integer>2085</integer>
          <key>col</key><integer>28</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2069</integer>
+         <key>line</key><integer>2085</integer>
          <key>col</key><integer>35</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>NSDictionary literal is an object with a +0 retain count</string>
      <key>message</key>
      <string>NSDictionary literal is an object with a +0 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2069</integer>
+      <key>line</key><integer>2085</integer>
       <key>col</key><integer>27</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2069</integer>
+         <key>line</key><integer>2085</integer>
          <key>col</key><integer>27</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2069</integer>
+         <key>line</key><integer>2085</integer>
          <key>col</key><integer>43</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>2069</integer>
+         <key>line</key><integer>2085</integer>
          <key>col</key><integer>28</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2069</integer>
+         <key>line</key><integer>2085</integer>
          <key>col</key><integer>35</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2069</integer>
+           <key>line</key><integer>2085</integer>
            <key>col</key><integer>27</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2069</integer>
+           <key>line</key><integer>2085</integer>
            <key>col</key><integer>27</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2069</integer>
+           <key>line</key><integer>2085</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2069</integer>
+           <key>line</key><integer>2085</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2069</integer>
+           <key>line</key><integer>2085</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2069</integer>
+           <key>line</key><integer>2085</integer>
            <key>col</key><integer>20</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2073</integer>
+           <key>line</key><integer>2089</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2073</integer>
+           <key>line</key><integer>2089</integer>
            <key>col</key><integer>9</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2073</integer>
+      <key>line</key><integer>2089</integer>
       <key>col</key><integer>9</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2073</integer>
+         <key>line</key><integer>2089</integer>
          <key>col</key><integer>9</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2073</integer>
+         <key>line</key><integer>2089</integer>
          <key>col</key><integer>23</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;a&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;a&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;a&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>3eee239ca30a84ef6ecc5d154ae8df28</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_objc_arrays</string>
   <key>issue_hash_function_offset</key><string>37</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>2073</integer>
+   <key>line</key><integer>2089</integer>
    <key>col</key><integer>9</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>2032</integer>
-    <integer>2034</integer>
-    <integer>2035</integer>
-    <integer>2036</integer>
-    <integer>2037</integer>
-    <integer>2038</integer>
-    <integer>2042</integer>
-    <integer>2043</integer>
-    <integer>2044</integer>
-    <integer>2045</integer>
-    <integer>2046</integer>
-    <integer>2047</integer>
+    <integer>2048</integer>
+    <integer>2050</integer>
     <integer>2051</integer>
     <integer>2052</integer>
     <integer>2053</integer>
     <integer>2054</integer>
-    <integer>2055</integer>
+    <integer>2058</integer>
     <integer>2059</integer>
     <integer>2060</integer>
     <integer>2061</integer>
+    <integer>2062</integer>
     <integer>2063</integer>
-    <integer>2064</integer>
+    <integer>2067</integer>
     <integer>2068</integer>
     <integer>2069</integer>
     <integer>2070</integer>
-    <integer>2072</integer>
-    <integer>2073</integer>
+    <integer>2071</integer>
+    <integer>2075</integer>
+    <integer>2076</integer>
+    <integer>2077</integer>
+    <integer>2079</integer>
+    <integer>2080</integer>
+    <integer>2084</integer>
+    <integer>2085</integer>
+    <integer>2086</integer>
+    <integer>2088</integer>
+    <integer>2089</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2078</integer>
+           <key>line</key><integer>2094</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2078</integer>
+           <key>line</key><integer>2094</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2078</integer>
+           <key>line</key><integer>2094</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2078</integer>
+           <key>line</key><integer>2094</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2078</integer>
+      <key>line</key><integer>2094</integer>
       <key>col</key><integer>15</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2078</integer>
+         <key>line</key><integer>2094</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2078</integer>
+         <key>line</key><integer>2094</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>NSNumber literal is an object with a +0 retain count</string>
      <key>message</key>
      <string>NSNumber literal is an object with a +0 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2078</integer>
+      <key>line</key><integer>2094</integer>
       <key>col</key><integer>14</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2078</integer>
+         <key>line</key><integer>2094</integer>
          <key>col</key><integer>14</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2078</integer>
+         <key>line</key><integer>2094</integer>
          <key>col</key><integer>24</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>2078</integer>
+         <key>line</key><integer>2094</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2078</integer>
+         <key>line</key><integer>2094</integer>
          <key>col</key><integer>16</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2078</integer>
+           <key>line</key><integer>2094</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2078</integer>
+           <key>line</key><integer>2094</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2078</integer>
+           <key>line</key><integer>2094</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2078</integer>
+           <key>line</key><integer>2094</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2078</integer>
+           <key>line</key><integer>2094</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2078</integer>
+           <key>line</key><integer>2094</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2079</integer>
+           <key>line</key><integer>2095</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2079</integer>
+           <key>line</key><integer>2095</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2079</integer>
+           <key>line</key><integer>2095</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2079</integer>
+           <key>line</key><integer>2095</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2080</integer>
+           <key>line</key><integer>2096</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2080</integer>
+           <key>line</key><integer>2096</integer>
            <key>col</key><integer>1</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2080</integer>
+      <key>line</key><integer>2096</integer>
       <key>col</key><integer>1</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;value&apos; is not referenced later in this execution path and has a retain count of +1</string>
      <key>message</key>
      <string>Object leaked: object allocated and stored into &apos;value&apos; is not referenced later in this execution path and has a retain count of +1</string>
     </dict>
    </array>
    <key>description</key><string>Potential leak of an object stored into &apos;value&apos;</string>
    <key>category</key><string>Memory (Core Foundation/Objective-C/OSObject)</string>
    <key>type</key><string>Leak</string>
    <key>check_name</key><string>osx.cocoa.RetainCountBase</string>
    <!-- This hash is experimental and going to change! -->
    <key>issue_hash_content_of_line_in_context</key><string>cb86fdadd2217db6b784b37dc29eba34</string>
   <key>issue_context_kind</key><string>function</string>
   <key>issue_context</key><string>test_objc_integer_literals</string>
   <key>issue_hash_function_offset</key><string>1</string>
   <key>location</key>
   <dict>
-   <key>line</key><integer>2080</integer>
+   <key>line</key><integer>2096</integer>
    <key>col</key><integer>1</integer>
    <key>file</key><integer>0</integer>
   </dict>
   <key>ExecutedLines</key>
   <dict>
    <key>0</key>
    <array>
-    <integer>2077</integer>
-    <integer>2078</integer>
-    <integer>2079</integer>
-    <integer>2080</integer>
+    <integer>2093</integer>
+    <integer>2094</integer>
+    <integer>2095</integer>
+    <integer>2096</integer>
    </array>
   </dict>
   </dict>
   <dict>
    <key>path</key>
    <array>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2083</integer>
+           <key>line</key><integer>2099</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2083</integer>
+           <key>line</key><integer>2099</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2083</integer>
+           <key>line</key><integer>2099</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2083</integer>
+           <key>line</key><integer>2099</integer>
            <key>col</key><integer>15</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2083</integer>
+      <key>line</key><integer>2099</integer>
       <key>col</key><integer>15</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2083</integer>
+         <key>line</key><integer>2099</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2083</integer>
+         <key>line</key><integer>2099</integer>
          <key>col</key><integer>18</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>NSNumber boxed expression produces an object with a +0 retain count</string>
      <key>message</key>
      <string>NSNumber boxed expression produces an object with a +0 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2083</integer>
+      <key>line</key><integer>2099</integer>
       <key>col</key><integer>14</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2083</integer>
+         <key>line</key><integer>2099</integer>
          <key>col</key><integer>14</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2083</integer>
+         <key>line</key><integer>2099</integer>
          <key>col</key><integer>26</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
        <array>
         <dict>
-         <key>line</key><integer>2083</integer>
+         <key>line</key><integer>2099</integer>
          <key>col</key><integer>15</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2083</integer>
+         <key>line</key><integer>2099</integer>
          <key>col</key><integer>18</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
      <key>message</key>
      <string>Reference count incremented. The object now has a +1 retain count</string>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2083</integer>
+           <key>line</key><integer>2099</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2083</integer>
+           <key>line</key><integer>2099</integer>
            <key>col</key><integer>14</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2083</integer>
+           <key>line</key><integer>2099</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2083</integer>
+           <key>line</key><integer>2099</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>control</string>
      <key>edges</key>
       <array>
        <dict>
         <key>start</key>
          <array>
           <dict>
-           <key>line</key><integer>2083</integer>
+           <key>line</key><integer>2099</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2083</integer>
+           <key>line</key><integer>2099</integer>
            <key>col</key><integer>4</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
         <key>end</key>
          <array>
           <dict>
-           <key>line</key><integer>2087</integer>
+           <key>line</key><integer>2103</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
           <dict>
-           <key>line</key><integer>2087</integer>
+           <key>line</key><integer>2103</integer>
            <key>col</key><integer>3</integer>
            <key>file</key><integer>0</integer>
           </dict>
          </array>
        </dict>
       </array>
     </dict>
     <dict>
      <key>kind</key><string>event</string>
      <key>location</key>
      <dict>
-      <key>line</key><integer>2087</integer>
+      <key>line</key><integer>2103</integer>
       <key>col</key><integer>3</integer>
       <key>file</key><integer>0</integer>
      </dict>
      <key>ranges</key>
      <array>
        <array>
         <dict>
-         <key>line</key><integer>2087</integer>
+         <key>line</key><integer>2103</integer>
          <key>col</key><integer>3</integer>
          <key>file</key><integer>0</integer>
         </dict>
         <dict>
-         <key>line</key><integer>2087</integer>
+         <key>line</key><integer>2103</integer>
          <key>col</key><integer>21</integer>
          <key>file</key><integer>0</integer>
         </dict>
        </array>
      </array>
      <key>depth</key><integer>0</integer>
      <key>extended_message</key>
      <string>Object leaked: object allocated and stored into &apos;value&apos; is not referenced later in t