diff --git a/runtime/vm/clustered_snapshot.cc b/runtime/vm/clustered_snapshot.cc
index fa44bea..fbc6871 100644
--- a/runtime/vm/clustered_snapshot.cc
+++ b/runtime/vm/clustered_snapshot.cc
@@ -1635,35 +1635,74 @@
                            active_unchecked_offset, code, deferred);
     }
 
-    // No need to write object pool out if we are producing full AOT
-    // snapshot with bare instructions.
-    if (!(kind == Snapshot::kFullAOT && FLAG_use_bare_instructions)) {
-      WriteField(code, object_pool_);
-#if defined(DART_PRECOMPILER)
-    } else if (FLAG_write_v8_snapshot_profile_to != nullptr &&
-               code->untag()->object_pool_ != ObjectPool::null()) {
-      // If we are writing V8 snapshot profile then attribute references
-      // going through the object pool to the code object itself.
-      ObjectPoolPtr pool = code->untag()->object_pool_;
-
-      for (intptr_t i = 0; i < pool->untag()->length_; i++) {
-        uint8_t bits = pool->untag()->entry_bits()[i];
-        if (ObjectPool::TypeBits::decode(bits) ==
-            ObjectPool::EntryType::kTaggedObject) {
-          s->AttributeElementRef(pool->untag()->data()[i].raw_obj_, i);
-        }
-      }
-#endif  // defined(DART_PRECOMPILER)
-    }
-    WriteField(code, owner_);
-    WriteField(code, exception_handlers_);
-    WriteField(code, pc_descriptors_);
-    WriteField(code, catch_entry_);
     if (s->InCurrentLoadingUnit(code->untag()->compressed_stackmaps_)) {
       WriteField(code, compressed_stackmaps_);
     } else {
       WriteFieldValue(compressed_stackmaps_, CompressedStackMaps::null());
     }
+
+    s->Write<int32_t>(code->untag()->state_bits_);
+
+#if defined(DART_PRECOMPILER)
+    if (FLAG_write_v8_snapshot_profile_to != nullptr) {
+      // If we are writing V8 snapshot profile then attribute references going
+      // through the object pool and static calls to the code object itself.
+      if (kind == Snapshot::kFullAOT && FLAG_use_bare_instructions &&
+          code->untag()->object_pool_ != ObjectPool::null()) {
+        ObjectPoolPtr pool = code->untag()->object_pool_;
+
+        for (intptr_t i = 0; i < pool->untag()->length_; i++) {
+          uint8_t bits = pool->untag()->entry_bits()[i];
+          if (ObjectPool::TypeBits::decode(bits) ==
+              ObjectPool::EntryType::kTaggedObject) {
+            s->AttributeElementRef(pool->untag()->data()[i].raw_obj_, i);
+          }
+        }
+      }
+      if (code->untag()->static_calls_target_table_ != Array::null()) {
+        array_ = code->untag()->static_calls_target_table_;
+        intptr_t index = code->untag()->object_pool_ != ObjectPool::null()
+                             ? code->untag()->object_pool_->untag()->length_
+                             : 0;
+        for (auto entry : StaticCallsTable(array_)) {
+          auto kind = Code::KindField::decode(
+              Smi::Value(entry.Get<Code::kSCallTableKindAndOffset>()));
+          switch (kind) {
+            case Code::kCallViaCode:
+              // Code object in the pool.
+              continue;
+            case Code::kPcRelativeTTSCall:
+              // TTS will be reachable through type object which itself is
+              // in the pool.
+              continue;
+            case Code::kPcRelativeCall:
+            case Code::kPcRelativeTailCall:
+              auto destination = entry.Get<Code::kSCallTableCodeOrTypeTarget>();
+              ASSERT(destination->IsHeapObject() && destination->IsCode());
+              s->AttributeElementRef(destination, index++);
+          }
+        }
+      }
+    }
+#endif  // defined(DART_PRECOMPILER)
+
+    if (Code::IsDiscarded(code)) {
+      // Only write instructions, compressed stackmaps and state bits
+      // for the discarded Code objects.
+      ASSERT(kind == Snapshot::kFullAOT && FLAG_use_bare_instructions &&
+             FLAG_dwarf_stack_traces_mode && !FLAG_retain_code_objects);
+      return;
+    }
+
+    // No need to write object pool out if we are producing full AOT
+    // snapshot with bare instructions.
+    if (!(kind == Snapshot::kFullAOT && FLAG_use_bare_instructions)) {
+      WriteField(code, object_pool_);
+    }
+    WriteField(code, owner_);
+    WriteField(code, exception_handlers_);
+    WriteField(code, pc_descriptors_);
+    WriteField(code, catch_entry_);
     if (FLAG_precompiled_mode && FLAG_dwarf_stack_traces_mode) {
       WriteFieldValue(inlined_id_to_function_, Array::null());
       WriteFieldValue(code_source_map_, CodeSourceMap::null());
@@ -1680,43 +1719,12 @@
       WriteField(code, static_calls_target_table_);
     }
 
-#if defined(DART_PRECOMPILER)
-    if (FLAG_write_v8_snapshot_profile_to != nullptr &&
-        code->untag()->static_calls_target_table_ != Array::null()) {
-      // If we are writing V8 snapshot profile then attribute references
-      // going through static calls.
-      array_ = code->untag()->static_calls_target_table_;
-      intptr_t index = code->untag()->object_pool_ != ObjectPool::null()
-                           ? code->untag()->object_pool_->untag()->length_
-                           : 0;
-      for (auto entry : StaticCallsTable(array_)) {
-        auto kind = Code::KindField::decode(
-            Smi::Value(entry.Get<Code::kSCallTableKindAndOffset>()));
-        switch (kind) {
-          case Code::kCallViaCode:
-            // Code object in the pool.
-            continue;
-          case Code::kPcRelativeTTSCall:
-            // TTS will be reachable through type object which itself is
-            // in the pool.
-            continue;
-          case Code::kPcRelativeCall:
-          case Code::kPcRelativeTailCall:
-            auto destination = entry.Get<Code::kSCallTableCodeOrTypeTarget>();
-            ASSERT(destination->IsHeapObject() && destination->IsCode());
-            s->AttributeElementRef(destination, index++);
-        }
-      }
-    }
-#endif  // defined(DART_PRECOMPILER)
-
 #if !defined(PRODUCT)
     WriteField(code, return_address_metadata_);
     if (FLAG_code_comments) {
       WriteField(code, comments_);
     }
 #endif
-    s->Write<int32_t>(code->untag()->state_bits_);
   }
 
   GrowableArray<CodePtr>* discovered_objects() { return &objects_; }
@@ -1732,7 +1740,7 @@
     for (auto code : objects_) {
       ObjectPtr owner =
           WeakSerializationReference::Unwrap(code->untag()->owner_);
-      if (s->CreateArtificalNodeIfNeeded(owner)) {
+      if (s->CreateArtificalNodeIfNeeded(owner) || Code::IsDiscarded(code)) {
         AutoTraceObject(code);
         s->AttributePropertyRef(owner, ":owner_",
                                 /*permit_artificial_ref=*/true);
@@ -1798,6 +1806,19 @@
 
     d->ReadInstructions(code, deferred);
 
+    code->untag()->compressed_stackmaps_ =
+        static_cast<CompressedStackMapsPtr>(d->ReadRef());
+    code->untag()->state_bits_ = d->Read<int32_t>();
+
+#if defined(DART_PRECOMPILED_RUNTIME)
+    if (Code::IsDiscarded(code)) {
+      code->untag()->owner_ = Smi::New(kFunctionCid);
+      return;
+    }
+#else
+    ASSERT(!Code::IsDiscarded(code));
+#endif  // defined(DART_PRECOMPILED_RUNTIME)
+
     // There would be a single global pool if this is a full AOT snapshot
     // with bare instructions.
     if (!(d->kind() == Snapshot::kFullAOT && FLAG_use_bare_instructions)) {
@@ -1811,8 +1832,6 @@
     code->untag()->pc_descriptors_ =
         static_cast<PcDescriptorsPtr>(d->ReadRef());
     code->untag()->catch_entry_ = d->ReadRef();
-    code->untag()->compressed_stackmaps_ =
-        static_cast<CompressedStackMapsPtr>(d->ReadRef());
     code->untag()->inlined_id_to_function_ =
         static_cast<ArrayPtr>(d->ReadRef());
     code->untag()->code_source_map_ =
@@ -1834,8 +1853,6 @@
                                    : Array::null();
     code->untag()->compile_timestamp_ = 0;
 #endif
-
-    code->untag()->state_bits_ = d->Read<int32_t>();
   }
 
   void PostLoad(Deserializer* d, const Array& refs, bool is_canonical) {
diff --git a/runtime/vm/compiler/aot/precompiler.cc b/runtime/vm/compiler/aot/precompiler.cc
index 22ded31..08be7fb 100644
--- a/runtime/vm/compiler/aot/precompiler.cc
+++ b/runtime/vm/compiler/aot/precompiler.cc
@@ -170,6 +170,10 @@
       pending_functions_(
           GrowableObjectArray::Handle(GrowableObjectArray::New())),
       sent_selectors_(),
+      entry_point_functions_(
+          HashTables::New<FunctionSet>(/*initial_capacity=*/128)),
+      functions_called_dynamically_(
+          HashTables::New<FunctionSet>(/*initial_capacity=*/1024)),
       seen_functions_(HashTables::New<FunctionSet>(/*initial_capacity=*/1024)),
       possibly_retained_functions_(
           HashTables::New<FunctionSet>(/*initial_capacity=*/1024)),
@@ -192,6 +196,8 @@
 
 Precompiler::~Precompiler() {
   // We have to call Release() in DEBUG mode.
+  entry_point_functions_.Release();
+  functions_called_dynamically_.Release();
   seen_functions_.Release();
   possibly_retained_functions_.Release();
   functions_to_retain_.Release();
@@ -445,6 +451,7 @@
              non_visited.ToFullyQualifiedCString());
     }
 #endif
+    DiscardCodeObjects();
     ProgramVisitor::Dedup(T);
 
     zone_ = NULL;
@@ -796,6 +803,11 @@
   if (functions_to_retain_.ContainsKey(function)) return;
   functions_to_retain_.Insert(function);
 
+  if (function.NeedsMonomorphicCheckedEntry(Z) ||
+      Function::IsDynamicInvocationForwarderName(function.name())) {
+    functions_called_dynamically_.Insert(function);
+  }
+
   const FunctionType& signature = FunctionType::Handle(Z, function.signature());
   AddType(signature);
 
@@ -1079,6 +1091,7 @@
   }
 
   if (possibly_retained_functions_.ContainsKey(function)) return;
+
   if (retain || MustRetainFunction(function)) {
     possibly_retained_functions_.Insert(function);
   }
@@ -1239,6 +1252,7 @@
           if (type == EntryPointPragma::kAlways ||
               type == EntryPointPragma::kCallOnly) {
             AddFunction(function);
+            entry_point_functions_.Insert(function);
           }
 
           if ((type == EntryPointPragma::kAlways ||
@@ -1247,10 +1261,12 @@
               !function.IsSetterFunction()) {
             function2 = function.ImplicitClosureFunction();
             AddFunction(function2);
+            entry_point_functions_.Insert(function2);
           }
 
           if (function.IsGenerativeConstructor()) {
             AddInstantiatedClass(cls);
+            entry_point_functions_.Insert(function);
           }
         }
         if (function.kind() == UntaggedFunction::kImplicitGetter &&
@@ -1259,6 +1275,7 @@
             field ^= implicit_getters.At(i);
             if (function.accessor_field() == field.ptr()) {
               AddFunction(function);
+              entry_point_functions_.Insert(function);
             }
           }
         }
@@ -1268,6 +1285,7 @@
             field ^= implicit_setters.At(i);
             if (function.accessor_field() == field.ptr()) {
               AddFunction(function);
+              entry_point_functions_.Insert(function);
             }
           }
         }
@@ -1277,6 +1295,7 @@
             field ^= implicit_static_getters.At(i);
             if (function.accessor_field() == field.ptr()) {
               AddFunction(function);
+              entry_point_functions_.Insert(function);
             }
           }
         }
@@ -2397,6 +2416,139 @@
   libraries_ = retained_libraries.ptr();
 }
 
+// Traverse program structure and mark Code objects
+// which do not have useful information as discarded.
+void Precompiler::DiscardCodeObjects() {
+  class DiscardCodeVisitor : public CodeVisitor {
+   public:
+    DiscardCodeVisitor(Zone* zone,
+                       const FunctionSet& functions_to_retain,
+                       const FunctionSet& entry_point_functions,
+                       const FunctionSet& functions_called_dynamically)
+        : zone_(zone),
+          function_(Function::Handle(zone)),
+          functions_to_retain_(functions_to_retain),
+          entry_point_functions_(entry_point_functions),
+          functions_called_dynamically_(functions_called_dynamically) {}
+
+    void VisitCode(const Code& code) override {
+      ++total_code_objects_;
+
+      // Only discard Code objects corresponding to Dart functions.
+      if (!code.IsFunctionCode()) {
+        ++non_function_codes_;
+        return;
+      }
+
+      // Retain Code object if it has exception handlers or PC descriptors.
+      if (code.exception_handlers() !=
+          Object::empty_exception_handlers().ptr()) {
+        ++codes_with_exception_handlers_;
+        return;
+      }
+      if (code.pc_descriptors() != Object::empty_descriptors().ptr()) {
+        ++codes_with_pc_descriptors_;
+        return;
+      }
+
+      function_ = code.function();
+      if (functions_to_retain_.ContainsKey(function_)) {
+        // Retain Code objects corresponding to:
+        // * invisible functions (to filter them from stack traces);
+        // * async/async* closures (to construct async stacks).
+        // * native functions (to find native implementation).
+        if (!function_.is_visible()) {
+          ++codes_with_invisible_function_;
+          return;
+        }
+        if (function_.is_native()) {
+          ++codes_with_native_function_;
+          return;
+        }
+        if (function_.IsAsyncClosure() || function_.IsAsyncGenClosure()) {
+          ++codes_with_async_closure_function_;
+          return;
+        }
+
+        // Retain Code objects for entry points.
+        if (entry_point_functions_.ContainsKey(function_)) {
+          ++codes_with_entry_point_function_;
+          return;
+        }
+
+        // Retain Code objects corresponding to dynamically
+        // called functions.
+        if (functions_called_dynamically_.ContainsKey(function_)) {
+          ++codes_with_dynamically_called_function_;
+          return;
+        }
+      } else {
+        ASSERT(!entry_point_functions_.ContainsKey(function_));
+        ASSERT(!functions_called_dynamically_.ContainsKey(function_));
+      }
+
+      code.set_is_discarded(true);
+      ++discarded_codes_;
+    }
+
+    void PrintStatistics() const {
+      THR_Print("Discarding Code objects:\n");
+      THR_Print("    %8" Pd " non-function Codes\n", non_function_codes_);
+      THR_Print("    %8" Pd " Codes with exception handlers\n",
+                codes_with_exception_handlers_);
+      THR_Print("    %8" Pd " Codes with pc descriptors\n",
+                codes_with_pc_descriptors_);
+      THR_Print("    %8" Pd " Codes with invisible functions\n",
+                codes_with_invisible_function_);
+      THR_Print("    %8" Pd " Codes with native functions\n",
+                codes_with_native_function_);
+      THR_Print("    %8" Pd " Codes with async closure functions\n",
+                codes_with_async_closure_function_);
+      THR_Print("    %8" Pd " Codes with dynamically called functions\n",
+                codes_with_dynamically_called_function_);
+      THR_Print("    %8" Pd " Codes with entry point functions\n",
+                codes_with_entry_point_function_);
+      THR_Print("    %8" Pd " Codes discarded\n", discarded_codes_);
+      THR_Print("    %8" Pd " Codes total\n", total_code_objects_);
+    }
+
+   private:
+    Zone* zone_;
+    Function& function_;
+    const FunctionSet& functions_to_retain_;
+    const FunctionSet& entry_point_functions_;
+    const FunctionSet& functions_called_dynamically_;
+
+    // Statistics
+    intptr_t total_code_objects_ = 0;
+    intptr_t non_function_codes_ = 0;
+    intptr_t codes_with_exception_handlers_ = 0;
+    intptr_t codes_with_pc_descriptors_ = 0;
+    intptr_t codes_with_invisible_function_ = 0;
+    intptr_t codes_with_native_function_ = 0;
+    intptr_t codes_with_async_closure_function_ = 0;
+    intptr_t codes_with_dynamically_called_function_ = 0;
+    intptr_t codes_with_entry_point_function_ = 0;
+    intptr_t discarded_codes_ = 0;
+  };
+
+  // Code objects are stored in stack frames if not use_bare_instructions.
+  // Code objects are used by stack traces if not dwarf_stack_traces.
+  // Code objects are used by profiler in non-PRODUCT mode.
+  if (!FLAG_use_bare_instructions || !FLAG_dwarf_stack_traces_mode ||
+      FLAG_retain_code_objects) {
+    return;
+  }
+
+  DiscardCodeVisitor visitor(Z, functions_to_retain_, entry_point_functions_,
+                             functions_called_dynamically_);
+  ProgramVisitor::WalkProgram(Z, IG, &visitor);
+
+  if (FLAG_trace_precompiler) {
+    visitor.PrintStatistics();
+  }
+}
+
 // Traits for the HashTable template.
 struct CodeKeyTraits {
   static uint32_t Hash(const Object& key) { return Code::Cast(key).Size(); }
diff --git a/runtime/vm/compiler/aot/precompiler.h b/runtime/vm/compiler/aot/precompiler.h
index 42406c4..4544053 100644
--- a/runtime/vm/compiler/aot/precompiler.h
+++ b/runtime/vm/compiler/aot/precompiler.h
@@ -333,6 +333,7 @@
   void DropLibraryEntries();
   void DropClasses();
   void DropLibraries();
+  void DiscardCodeObjects();
 
   DEBUG_ONLY(FunctionPtr FindUnvisitedRetainedFunction());
 
@@ -376,6 +377,8 @@
   GrowableObjectArray& libraries_;
   const GrowableObjectArray& pending_functions_;
   SymbolSet sent_selectors_;
+  FunctionSet entry_point_functions_;
+  FunctionSet functions_called_dynamically_;
   FunctionSet seen_functions_;
   FunctionSet possibly_retained_functions_;
   FieldSet fields_to_retain_;
diff --git a/runtime/vm/flag_list.h b/runtime/vm/flag_list.h
index f6c90bf..c118e0f 100644
--- a/runtime/vm/flag_list.h
+++ b/runtime/vm/flag_list.h
@@ -194,6 +194,9 @@
   P(retain_function_objects, bool, true,                                       \
     "Serialize function objects for all code objects even if not otherwise "   \
     "needed in the precompiled runtime.")                                      \
+  P(retain_code_objects, bool, true,                                           \
+    "Serialize all code objects even if not otherwise "                        \
+    "needed in the precompiled runtime.")                                      \
   P(enable_isolate_groups, bool, false,                                        \
     "Enable isolate group support in AOT.")                                    \
   P(experimental_enable_isolate_groups_jit, bool, false,                       \
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 1d8c7ac..007ceb4 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -16250,6 +16250,10 @@
   set_state_bits(AliveBit::update(value, untag()->state_bits_));
 }
 
+void Code::set_is_discarded(bool value) const {
+  set_state_bits(DiscardedBit::update(value, untag()->state_bits_));
+}
+
 void Code::set_compressed_stackmaps(const CompressedStackMaps& maps) const {
   ASSERT(maps.IsOld());
   untag()->set_compressed_stackmaps(maps.ptr());
@@ -17079,41 +17083,6 @@
   reader.DumpSourcePositions(relative_addresses ? 0 : PayloadStart());
 }
 
-bool Code::CanBeOmittedFromAOTSnapshot() const {
-  NoSafepointScope no_safepoint;
-
-  // Code objects are stored in stack frames if not use_bare_instructions.
-  // Code objects are used by stack traces if not dwarf_stack_traces.
-  if (!FLAG_precompiled_mode || !FLAG_use_bare_instructions ||
-      !FLAG_dwarf_stack_traces_mode) {
-    return false;
-  }
-  // Only omit Code objects corresponding to Dart functions.
-  if (!IsFunctionCode()) {
-    return false;
-  }
-  // Retain Code object if it has exception handlers or PC descriptors.
-  if ((exception_handlers() != Object::empty_exception_handlers().ptr()) ||
-      (pc_descriptors() != Object::empty_descriptors().ptr())) {
-    return false;
-  }
-  if (!owner()->IsHeapObject()) {
-    // Can drop Code if precompiler dropped the Function and only left Smi
-    // classId.
-    return true;
-  }
-  // Retain Code objects corresponding to:
-  // * invisible functions (to filter them from stack traces);
-  // * async/async* closures (to construct async stacks).
-  // * native functions (to find native implementation).
-  const auto& func = Function::Handle(function());
-  if (!func.is_visible() || func.is_native() || func.IsAsyncClosure() ||
-      func.IsAsyncGenClosure()) {
-    return false;
-  }
-  return true;
-}
-
 intptr_t Context::GetLevel() const {
   intptr_t level = 0;
   Context& parent_ctx = Context::Handle(parent());
@@ -25090,6 +25059,7 @@
   // debugging options like the observatory available.
   if (value) {
     FLAG_retain_function_objects = false;
+    FLAG_retain_code_objects = false;
   }
 #endif
 }
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 8b81dc7..17187ee 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -5956,6 +5956,12 @@
   bool is_alive() const { return AliveBit::decode(untag()->state_bits_); }
   void set_is_alive(bool value) const;
 
+  bool is_discarded() const { return IsDiscarded(ptr()); }
+  static bool IsDiscarded(const CodePtr code) {
+    return DiscardedBit::decode(code->untag()->state_bits_);
+  }
+  void set_is_discarded(bool value) const;
+
   bool HasMonomorphicEntry() const { return HasMonomorphicEntry(ptr()); }
   static bool HasMonomorphicEntry(const CodePtr code) {
 #if defined(DART_PRECOMPILED_RUNTIME)
@@ -6378,11 +6384,6 @@
     untag()->set_object_pool(object_pool);
   }
 
-  // Returns true if given Code object can be omitted from
-  // the AOT snapshot (when corresponding instructions are
-  // included).
-  bool CanBeOmittedFromAOTSnapshot() const;
-
  private:
   void set_state_bits(intptr_t bits) const;
 
@@ -6392,8 +6393,9 @@
     kOptimizedBit = 0,
     kForceOptimizedBit = 1,
     kAliveBit = 2,
-    kPtrOffBit = 3,
-    kPtrOffSize = 29,
+    kDiscardedBit = 3,
+    kPtrOffBit = 4,
+    kPtrOffSize = kBitsPerInt32 - kPtrOffBit,
   };
 
   class OptimizedBit : public BitField<int32_t, bool, kOptimizedBit, 1> {};
@@ -6404,6 +6406,13 @@
       : public BitField<int32_t, bool, kForceOptimizedBit, 1> {};
 
   class AliveBit : public BitField<int32_t, bool, kAliveBit, 1> {};
+
+  // Set by precompiler if this Code object doesn't contain
+  // useful information besides instructions and compressed stack map.
+  // Such object is serialized in a shorter form. (In future such
+  // Code objects will not be re-created during snapshot deserialization.)
+  class DiscardedBit : public BitField<int32_t, bool, kDiscardedBit, 1> {};
+
   class PtrOffBits
       : public BitField<int32_t, intptr_t, kPtrOffBit, kPtrOffSize> {};
 
diff --git a/runtime/vm/stack_frame.cc b/runtime/vm/stack_frame.cc
index 037e70d..f5df240 100644
--- a/runtime/vm/stack_frame.cc
+++ b/runtime/vm/stack_frame.cc
@@ -359,7 +359,7 @@
       // behavior of ReversePc::Lookup which will return
       // StubCode::UnknownDartCode() if code object is omitted from
       // the snapshot.
-      if (FLAG_dwarf_stack_traces_mode && code.CanBeOmittedFromAOTSnapshot()) {
+      if (code.is_discarded()) {
         ASSERT(StubCode::UnknownDartCode().PayloadStart() == 0);
         ASSERT(StubCode::UnknownDartCode().Size() == kUwordMax);
         ASSERT(StubCode::UnknownDartCode().IsFunctionCode());
diff --git a/tools/VERSION b/tools/VERSION
index 06f4903..fa72651 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 13
 PATCH 0
-PRERELEASE 87
+PRERELEASE 88
 PRERELEASE_PATCH 0
\ No newline at end of file