anchor.diff:    final List<String> flutterPlugins = [];
     final List<String> flutterSdks = [];
   
  -  Map<String, int> homepageDomains = {};
  -  void addHomepage(String key) {
  -    homepageDomains[key] = (homepageDomains[key] ?? 0) + 1;
  -  }
  +  final homepageScheme = _Counter();
  +  final licenseCounts = _Counter();
  +  final licenseNames = _Counter();
  +  final packagesWithMoreThanOneLicense = _Counter();
  +  final grantedPoints = _Counter();
  +  final tags = _Counter();
   
     await withProdServices(() async {
  -    await for (Package p in dbService.query<Package>().run()) {
  +    Future<void> process(Package p) async {
         totalCount++;
         if (totalCount % 25 == 0) {
           print('Reading package #$totalCount: ${p.name}');
         }
   
  -      final List<PackageVersion> versions =
  -          await dbService.lookup([p.latestVersionKey]);
  -      if (versions.isEmpty) continue;
  -
  -      final PackageVersion latest = versions.first;
  -      final Pubspec pubspec = latest.pubspec;
  +      final latest =
  +          await dbService.lookupValue<PackageVersion>(p.latestVersionKey);
  +      final pubspec = latest.pubspec;
   
         if (pubspec.hasFlutterPlugin) {
           flutterPlugins.add(p.name);
  
positive.code: 
  import 'package:args/args.dart';
  import 'package:gcloud/db.dart';
  
  import 'package:pub_dev/package/models.dart';
  import 'package:pub_dev/package/model_properties.dart';
  import 'package:pub_dev/service/entrypoint/tools.dart';
  
  Future main(List<String> args) async {
  
negative.code:   }
  }
  
  class _Counter {
    final _values = <String, int>{};
  
    void increment(key, [int amount = 1]) {
      final strKey = key.toString();
      _values[strKey] = (_values[strKey] ?? 0) + amount;
    }
  
    Map<String, int> sortedByCounts() {
      final keys = _values.keys.toList();
      keys.sort((a, b) => -_values[a].compareTo(_values[b]));
      final result = <String, int>{};
      for (String key in keys) {
        result[key] = _values[key];
      }
      return result;
    }
  
    Map<String, int> sortedByKeysAsInt() {
      final keys = _values.keys.map(int.parse).toList();
      keys.sort((a, b) => a.compareTo(b));
      final result = <String, int>{};
      for (int key in keys) {
        final strKey = key.toString();
        result[strKey] = _values[strKey];
      }
      return result;
    }
  }
  