DANGER! MERGED IN ENGINE-289! SOME DOC BUGS STILL EXIST - USE WITH CARE!!!
authorKrista Bennett <krista@pep-project.org>
Thu, 18 Jan 2018 00:46:19 +0100
changeset 2410721952accdee
parent 2400 424f37a81a6b
parent 2409 8647f504dc4d
child 2411 406244dbf80c
DANGER! MERGED IN ENGINE-289! SOME DOC BUGS STILL EXIST - USE WITH CARE!!!
     1.1 --- a/default.conf	Wed Jan 17 11:16:22 2018 +0100
     1.2 +++ b/default.conf	Thu Jan 18 00:46:19 2018 +0100
     1.3 @@ -99,7 +99,7 @@
     1.4          CFLAGS+= -w
     1.5      endif
     1.6      ifdef DEBUG
     1.7 -        CFLAGS+= -Og -ggdb -DDEBUG_ERRORSTACK
     1.8 +        CFLAGS+= -g -ggdb -DDEBUG_ERRORSTACK
     1.9      else
    1.10          CFLAGS+= -O3 -DNDEBUG
    1.11      endif
    1.12 @@ -148,7 +148,7 @@
    1.13          CXXFLAGS+= -w
    1.14      endif
    1.15      ifdef DEBUG
    1.16 -        CXXFLAGS+= -Og -ggdb
    1.17 +        CXXFLAGS+= -g -ggdb
    1.18      else
    1.19          CXXFLAGS+= -O3 -DNDEBUG
    1.20      endif
     2.1 --- a/src/keymanagement.c	Wed Jan 17 11:16:22 2018 +0100
     2.2 +++ b/src/keymanagement.c	Thu Jan 18 00:46:19 2018 +0100
     2.3 @@ -12,6 +12,7 @@
     2.4  #include "pEp_internal.h"
     2.5  #include "keymanagement.h"
     2.6  
     2.7 +#include "sync_fsm.h"
     2.8  #include "blacklist.h"
     2.9  
    2.10  #ifndef EMPTYSTR
    2.11 @@ -20,6 +21,32 @@
    2.12  
    2.13  #define KEY_EXPIRE_DELTA (60 * 60 * 24 * 365)
    2.14  
    2.15 +
    2.16 +static bool key_matches_address(PEP_SESSION session, const char* address,
    2.17 +                                const char* fpr) {
    2.18 +    if (!session || !address || !fpr)
    2.19 +        return false;
    2.20 +    
    2.21 +    bool retval = false;
    2.22 +    stringlist_t *keylist = NULL;
    2.23 +    PEP_STATUS status = find_keys(session, address, &keylist);
    2.24 +    if (status == PEP_STATUS_OK && keylist) {
    2.25 +        stringlist_t* curr = keylist;
    2.26 +        while (curr) {
    2.27 +            if (curr->value) {
    2.28 +                if (strcasecmp(curr->value, fpr)) {
    2.29 +                    retval = true;
    2.30 +                    break;
    2.31 +                }
    2.32 +            }
    2.33 +            curr = curr->next;
    2.34 +        }
    2.35 +    }
    2.36 +    
    2.37 +    free_stringlist(keylist);
    2.38 +    return retval;                             
    2.39 +}
    2.40 +
    2.41  PEP_STATUS elect_pubkey(
    2.42          PEP_SESSION session, pEp_identity * identity
    2.43      )
    2.44 @@ -33,36 +60,37 @@
    2.45      assert(status != PEP_OUT_OF_MEMORY);
    2.46      if (status == PEP_OUT_OF_MEMORY)
    2.47          return PEP_OUT_OF_MEMORY;
    2.48 +    
    2.49 +    if (!keylist || !keylist->value)
    2.50 +        identity->comm_type = PEP_ct_key_not_found;    
    2.51 +    else {
    2.52 +        stringlist_t *_keylist;
    2.53 +        for (_keylist = keylist; _keylist && _keylist->value; _keylist = _keylist->next) {
    2.54 +            PEP_comm_type _comm_type_key;
    2.55  
    2.56 -    stringlist_t *_keylist;
    2.57 -    for (_keylist = keylist; _keylist && _keylist->value; _keylist = _keylist->next) {
    2.58 -        PEP_comm_type _comm_type_key;
    2.59 +            status = get_key_rating(session, _keylist->value, &_comm_type_key);
    2.60 +            assert(status != PEP_OUT_OF_MEMORY);
    2.61 +            if (status == PEP_OUT_OF_MEMORY) {
    2.62 +                free_stringlist(keylist);
    2.63 +                return PEP_OUT_OF_MEMORY;
    2.64 +            }
    2.65  
    2.66 -        status = get_key_rating(session, _keylist->value, &_comm_type_key);
    2.67 -        assert(status != PEP_OUT_OF_MEMORY);
    2.68 -        if (status == PEP_OUT_OF_MEMORY) {
    2.69 -            free_stringlist(keylist);
    2.70 -            return PEP_OUT_OF_MEMORY;
    2.71 -        }
    2.72 -
    2.73 -        if (_comm_type_key != PEP_ct_compromized &&
    2.74 -            _comm_type_key != PEP_ct_unknown)
    2.75 -        {
    2.76 -            if (identity->comm_type == PEP_ct_unknown ||
    2.77 -                _comm_type_key > identity->comm_type)
    2.78 +            if (_comm_type_key != PEP_ct_compromized &&
    2.79 +                _comm_type_key != PEP_ct_unknown)
    2.80              {
    2.81 -                bool blacklisted;
    2.82 -                status = blacklist_is_listed(session, _keylist->value, &blacklisted);
    2.83 -                if (status == PEP_STATUS_OK && !blacklisted) {
    2.84 -                    identity->comm_type = _comm_type_key;
    2.85 -                    _fpr = _keylist->value;
    2.86 +                if (identity->comm_type == PEP_ct_unknown ||
    2.87 +                    _comm_type_key > identity->comm_type)
    2.88 +                {
    2.89 +                    bool blacklisted;
    2.90 +                    status = blacklist_is_listed(session, _keylist->value, &blacklisted);
    2.91 +                    if (status == PEP_STATUS_OK && !blacklisted) {
    2.92 +                        identity->comm_type = _comm_type_key;
    2.93 +                        _fpr = _keylist->value;
    2.94 +                    }
    2.95                  }
    2.96              }
    2.97          }
    2.98      }
    2.99 -
   2.100 -    
   2.101 -//    if (_fpr) {
   2.102      free(identity->fpr);
   2.103  
   2.104      identity->fpr = strdup(_fpr);
   2.105 @@ -70,19 +98,342 @@
   2.106          free_stringlist(keylist);
   2.107          return PEP_OUT_OF_MEMORY;
   2.108      }
   2.109 -//    }
   2.110 +    
   2.111      free_stringlist(keylist);
   2.112      return PEP_STATUS_OK;
   2.113  }
   2.114  
   2.115 -PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen, bool ignore_flags);
   2.116 +static PEP_STATUS validate_fpr(PEP_SESSION session, 
   2.117 +                               pEp_identity* ident) {
   2.118 +    
   2.119 +    PEP_STATUS status = PEP_STATUS_OK;
   2.120 +    
   2.121 +    if (!session || !ident || !ident->fpr || !ident->fpr[0])
   2.122 +        return PEP_ILLEGAL_VALUE;    
   2.123 +        
   2.124 +    char* fpr = ident->fpr;
   2.125 +    
   2.126 +    bool has_private = false;
   2.127 +    
   2.128 +    if (ident->me) {
   2.129 +        status = contains_priv_key(session, fpr, &has_private);
   2.130 +        if (status != PEP_STATUS_OK || !has_private)
   2.131 +            return PEP_KEY_UNSUITABLE;
   2.132 +    }
   2.133 +    
   2.134 +    status = get_trust(session, ident);
   2.135 +    if (status != PEP_STATUS_OK)
   2.136 +        ident->comm_type = PEP_ct_unknown;
   2.137 +            
   2.138 +    PEP_comm_type ct = ident->comm_type;
   2.139 +
   2.140 +    if (ct == PEP_ct_unknown) {
   2.141 +        // If status is bad, it's ok, we get the rating
   2.142 +        // we should use then (PEP_ct_unknown)
   2.143 +        get_key_rating(session, fpr, &ct);
   2.144 +        ident->comm_type = ct;
   2.145 +    }
   2.146 +    
   2.147 +    bool revoked, expired;
   2.148 +    bool blacklisted = false;
   2.149 +    
   2.150 +    status = key_revoked(session, fpr, &revoked);    
   2.151 +        
   2.152 +    if (status != PEP_STATUS_OK) {
   2.153 +        return ADD_TO_LOG(status);
   2.154 +    }
   2.155 +    
   2.156 +    if (!revoked) {
   2.157 +        time_t exp_time = (ident->me ? 
   2.158 +                           time(NULL) + (7*24*3600) : time(NULL));
   2.159 +                           
   2.160 +        status = key_expired(session, fpr, 
   2.161 +                             exp_time,
   2.162 +                             &expired);
   2.163 +                             
   2.164 +        assert(status == PEP_STATUS_OK);
   2.165 +        if (status != PEP_STATUS_OK)
   2.166 +            return ADD_TO_LOG(status);
   2.167 +
   2.168 +        if ((ct | PEP_ct_confirmed) == PEP_ct_OpenPGP &&
   2.169 +            !ident->me) {
   2.170 +            status = blacklist_is_listed(session, 
   2.171 +                                         fpr, 
   2.172 +                                         &blacklisted);
   2.173 +                                         
   2.174 +            if (status != PEP_STATUS_OK)
   2.175 +                return ADD_TO_LOG(status);
   2.176 +        }
   2.177 +    }
   2.178 +            
   2.179 +    if (ident->me && (ct >= PEP_ct_strong_but_unconfirmed) && !revoked && expired) {
   2.180 +        // extend key
   2.181 +        timestamp *ts = new_timestamp(time(NULL) + KEY_EXPIRE_DELTA);
   2.182 +        status = renew_key(session, fpr, ts);
   2.183 +        free_timestamp(ts);
   2.184 +
   2.185 +        if (status == PEP_STATUS_OK) {
   2.186 +            // if key is valid (second check because pEp key might be extended above)
   2.187 +            //      Return fpr        
   2.188 +            status = key_expired(session, fpr, time(NULL), &expired);            
   2.189 +            if (status != PEP_STATUS_OK) {
   2.190 +                 ident->comm_type = PEP_ct_key_expired;
   2.191 +                 return ADD_TO_LOG(status);
   2.192 +             }
   2.193 +            // communicate key(?)
   2.194 +        }        
   2.195 +    }
   2.196 +     
   2.197 +    if (revoked) 
   2.198 +        ct = PEP_ct_key_revoked;
   2.199 +    else if (expired)
   2.200 +        ct = PEP_ct_key_expired;        
   2.201 +    else if (blacklisted) { // never true for .me
   2.202 +        ident->comm_type = ct = PEP_ct_key_not_found;
   2.203 +        free(ident->fpr);
   2.204 +            ident->fpr = strdup("");
   2.205 +        status = PEP_KEY_BLACKLISTED;
   2.206 +    }
   2.207 +    
   2.208 +    switch (ct) {
   2.209 +        case PEP_ct_key_expired:
   2.210 +        case PEP_ct_key_revoked:
   2.211 +        case PEP_ct_key_b0rken:
   2.212 +            // delete key from being default key for all users/identities
   2.213 +            status = remove_fpr_as_default(session, fpr);
   2.214 +            status = update_trust_for_fpr(session, 
   2.215 +                                          fpr, 
   2.216 +                                          ct);
   2.217 +            free(ident->fpr);
   2.218 +            ident->fpr = strdup("");
   2.219 +            ident->comm_type = ct;            
   2.220 +            status = PEP_KEY_UNSUITABLE;
   2.221 +        default:
   2.222 +            break;
   2.223 +    }            
   2.224 +
   2.225 +    return status;
   2.226 +}
   2.227 +
   2.228 +PEP_STATUS get_user_default_key(PEP_SESSION session, const char* user_id,
   2.229 +                                char** default_key) {
   2.230 +    assert(session);
   2.231 +    assert(user_id);
   2.232 +    
   2.233 +    if (!session || !user_id)
   2.234 +        return PEP_ILLEGAL_VALUE;
   2.235 +
   2.236 +    PEP_STATUS status = PEP_STATUS_OK;
   2.237 +            
   2.238 +    // try to get default key for user_data
   2.239 +    sqlite3_reset(session->get_user_default_key);
   2.240 +    sqlite3_bind_text(session->get_user_default_key, 1, user_id, 
   2.241 +                      -1, SQLITE_STATIC);
   2.242 +    
   2.243 +    const int result = sqlite3_step(session->get_user_default_key);
   2.244 +    char* user_fpr = NULL;
   2.245 +    if (result == SQLITE_ROW) {
   2.246 +        const char* u_fpr =
   2.247 +            (char *) sqlite3_column_text(session->get_user_default_key, 0);
   2.248 +        if (u_fpr)
   2.249 +            user_fpr = strdup(u_fpr);
   2.250 +    }
   2.251 +    else
   2.252 +        status = PEP_GET_KEY_FAILED;
   2.253 +        
   2.254 +    sqlite3_reset(session->get_user_default_key);
   2.255 +    
   2.256 +    *default_key = user_fpr;
   2.257 +    return status;     
   2.258 +}
   2.259 +
   2.260 +// Only call on retrieval of previously stored identity!
   2.261 +// Also, we presume that if the stored_identity was sent in
   2.262 +// without an fpr, there wasn't one in the trust DB for this
   2.263 +// identity.
   2.264 +PEP_STATUS get_valid_pubkey(PEP_SESSION session,
   2.265 +                         pEp_identity* stored_identity,
   2.266 +                         bool* is_identity_default,
   2.267 +                         bool* is_user_default,
   2.268 +                         bool* is_address_default) {
   2.269 +    
   2.270 +    PEP_STATUS status = PEP_STATUS_OK;
   2.271 +
   2.272 +    if (!stored_identity || !stored_identity->user_id
   2.273 +        || !is_identity_default || !is_user_default || !is_address_default)
   2.274 +        return PEP_ILLEGAL_VALUE;
   2.275 +        
   2.276 +    *is_identity_default = *is_user_default = *is_address_default = false;
   2.277 +
   2.278 +    PEP_comm_type first_reject_comm_type = PEP_ct_key_not_found;
   2.279 +    PEP_STATUS first_reject_status = PEP_KEY_NOT_FOUND;
   2.280 +    
   2.281 +    char* stored_fpr = stored_identity->fpr;
   2.282 +    // Input: stored identity retrieved from database
   2.283 +    // if stored identity contains a default key
   2.284 +    if (stored_fpr) {
   2.285 +        status = validate_fpr(session, stored_identity);    
   2.286 +        if (status == PEP_STATUS_OK && stored_identity->fpr) {
   2.287 +            *is_identity_default = *is_address_default = true;
   2.288 +            return status;
   2.289 +        }
   2.290 +        else if (status != PEP_KEY_NOT_FOUND) {
   2.291 +            first_reject_status = status;
   2.292 +            first_reject_comm_type = stored_identity->comm_type;
   2.293 +        }
   2.294 +    }
   2.295 +    // if no valid default stored identity key found
   2.296 +    free(stored_identity->fpr);
   2.297 +    stored_identity->fpr = NULL;
   2.298 +    
   2.299 +    char* user_fpr = NULL;
   2.300 +    status = get_user_default_key(session, stored_identity->user_id, &user_fpr);
   2.301 +    
   2.302 +    if (user_fpr) {             
   2.303 +        // There exists a default key for user, so validate
   2.304 +        stored_identity->fpr = user_fpr;
   2.305 +        status = validate_fpr(session, stored_identity);
   2.306 +        if (status == PEP_STATUS_OK && stored_identity->fpr) {
   2.307 +            *is_user_default = true;
   2.308 +            *is_address_default = key_matches_address(session, 
   2.309 +                                                      stored_identity->address,
   2.310 +                                                      stored_identity->fpr);
   2.311 +            return status;
   2.312 +        }        
   2.313 +        else if (status != PEP_KEY_NOT_FOUND && first_reject_status != PEP_KEY_NOT_FOUND) {
   2.314 +            first_reject_status = status;
   2.315 +            first_reject_comm_type = stored_identity->comm_type;
   2.316 +        }
   2.317 +    }
   2.318 +    
   2.319 +    status = elect_pubkey(session, stored_identity);
   2.320 +    if (status == PEP_STATUS_OK) {
   2.321 +        if (stored_identity->fpr)
   2.322 +            validate_fpr(session, stored_identity);
   2.323 +    }    
   2.324 +    else if (status != PEP_KEY_NOT_FOUND && first_reject_status != PEP_KEY_NOT_FOUND) {
   2.325 +        first_reject_status = status;
   2.326 +        first_reject_comm_type = stored_identity->comm_type;
   2.327 +    }
   2.328 +    
   2.329 +    switch (stored_identity->comm_type) {
   2.330 +        case PEP_ct_key_revoked:
   2.331 +        case PEP_ct_key_b0rken:
   2.332 +        case PEP_ct_key_expired:
   2.333 +        case PEP_ct_compromized:
   2.334 +        case PEP_ct_mistrusted:
   2.335 +            // this only happens when it's all there is
   2.336 +            status = first_reject_status;
   2.337 +            free(stored_identity->fpr);
   2.338 +            stored_identity->fpr = NULL;
   2.339 +            stored_identity->comm_type = first_reject_comm_type;
   2.340 +            break;    
   2.341 +        default:
   2.342 +            break;
   2.343 +    }
   2.344 +    return status;
   2.345 +}
   2.346 +
   2.347 +static void transfer_ident_lang_and_flags(pEp_identity* new_ident,
   2.348 +                                          pEp_identity* stored_ident) {
   2.349 +    if (new_ident->lang[0] == 0) {
   2.350 +      new_ident->lang[0] = stored_ident->lang[0];
   2.351 +      new_ident->lang[1] = stored_ident->lang[1];
   2.352 +      new_ident->lang[2] = 0;
   2.353 +    }
   2.354 +
   2.355 +    new_ident->flags = stored_ident->flags;
   2.356 +    new_ident->me = new_ident->me || stored_ident->me;
   2.357 +}
   2.358 +
   2.359 +static PEP_STATUS prepare_updated_identity(PEP_SESSION session,
   2.360 +                                                 pEp_identity* return_id,
   2.361 +                                                 pEp_identity* stored_ident,
   2.362 +                                                 bool store) {
   2.363 +    
   2.364 +    if (!session || !return_id || !stored_ident)
   2.365 +        return PEP_ILLEGAL_VALUE;
   2.366 +    
   2.367 +    PEP_STATUS status;
   2.368 +    
   2.369 +    bool is_identity_default, is_user_default, is_address_default;
   2.370 +    status = get_valid_pubkey(session, stored_ident,
   2.371 +                                &is_identity_default,
   2.372 +                                &is_user_default,
   2.373 +                                &is_address_default);
   2.374 +                                
   2.375 +    if (status == PEP_STATUS_OK && stored_ident->fpr && *(stored_ident->fpr) != '\0') {
   2.376 +    // set identity comm_type from trust db (user_id, FPR)
   2.377 +        status = get_trust(session, stored_ident);
   2.378 +        if (status == PEP_CANNOT_FIND_IDENTITY || stored_ident->comm_type == PEP_ct_unknown) {
   2.379 +            // This is OK - there is no trust DB entry, but we
   2.380 +            // found a key. We won't store this, but we'll
   2.381 +            // use it.
   2.382 +            PEP_comm_type ct = PEP_ct_unknown;
   2.383 +            status = get_key_rating(session, stored_ident->fpr, &ct);
   2.384 +            stored_ident->comm_type = ct;
   2.385 +        }
   2.386 +    }
   2.387 +    free(return_id->fpr);
   2.388 +    return_id->fpr = NULL;
   2.389 +    if (status == PEP_STATUS_OK && stored_ident->fpr)
   2.390 +        return_id->fpr = strdup(stored_ident->fpr);
   2.391 +        
   2.392 +    return_id->comm_type = stored_ident->comm_type;
   2.393 +                
   2.394 +    // We patch the DB with the input username, but if we didn't have
   2.395 +    // one, we pull it out of storage if available.
   2.396 +    // (also, if the input username is "anonymous" and there exists
   2.397 +    //  a DB username, we replace)
   2.398 +    if (stored_ident->username) {
   2.399 +        if (return_id->username && 
   2.400 +            (strcasecmp(return_id->username, "anonymous") == 0)) {
   2.401 +            free(return_id->username);
   2.402 +            return_id->username = NULL;
   2.403 +        }
   2.404 +        if (!return_id->username)
   2.405 +            return_id->username = strdup(stored_ident->username);
   2.406 +    }
   2.407 +    
   2.408 +    return_id->me = stored_ident->me;
   2.409 +    
   2.410 +    // FIXME: Do we ALWAYS do this? We probably should...
   2.411 +    if (!return_id->user_id)
   2.412 +        return_id->user_id = strdup(stored_ident->user_id);
   2.413 +        
   2.414 +    // Call set_identity() to store
   2.415 +    if ((is_identity_default || is_user_default) &&
   2.416 +         is_address_default) {                 
   2.417 +         // if we got an fpr which is default for either user
   2.418 +         // or identity AND is valid for this address, set in DB
   2.419 +         // as default
   2.420 +         status = set_identity(session, return_id);
   2.421 +    }
   2.422 +    else {
   2.423 +        // Store without default fpr/ct, but return the fpr and ct 
   2.424 +        // for current use
   2.425 +        char* save_fpr = return_id->fpr;
   2.426 +        PEP_comm_type save_ct = return_id->comm_type;
   2.427 +        return_id->fpr = NULL;
   2.428 +        return_id->comm_type = PEP_ct_unknown;
   2.429 +        PEP_STATUS save_status = status;
   2.430 +        status = set_identity(session, return_id);
   2.431 +        if (save_status != PEP_STATUS_OK)
   2.432 +            status = save_status;
   2.433 +        return_id->fpr = save_fpr;
   2.434 +        return_id->comm_type = save_ct;
   2.435 +    }
   2.436 +    
   2.437 +    transfer_ident_lang_and_flags(return_id, stored_ident);
   2.438 +    
   2.439 +    return status;
   2.440 +}
   2.441 +
   2.442  
   2.443  DYNAMIC_API PEP_STATUS update_identity(
   2.444          PEP_SESSION session, pEp_identity * identity
   2.445      )
   2.446  {
   2.447 -    pEp_identity *stored_identity = NULL;
   2.448 -    pEp_identity *temp_id = NULL;
   2.449      PEP_STATUS status;
   2.450  
   2.451      assert(session);
   2.452 @@ -92,237 +443,242 @@
   2.453      if (!(session && identity && !EMPTYSTR(identity->address)))
   2.454          return ADD_TO_LOG(PEP_ILLEGAL_VALUE);
   2.455  
   2.456 -    if (_identity_me(identity)) {
   2.457 -        return _myself(session, identity, false, true);
   2.458 +    char* default_own_id = NULL;
   2.459 +    status = get_default_own_userid(session, &default_own_id);    
   2.460 +
   2.461 +    // Is this me, temporary or not? If so, BAIL.
   2.462 +    if (identity->me || 
   2.463 +       (default_own_id && identity->user_id && (strcmp(default_own_id, identity->user_id) == 0))) 
   2.464 +    {
   2.465 +        return PEP_ILLEGAL_VALUE;
   2.466      }
   2.467  
   2.468 -    int _no_user_id = EMPTYSTR(identity->user_id);
   2.469 -    int _did_elect_new_key = 0;
   2.470 +    // We have, at least, an address.
   2.471 +    // Retrieve stored identity information!    
   2.472 +    pEp_identity* stored_ident = NULL;
   2.473  
   2.474 -    if (_no_user_id)
   2.475 -    {
   2.476 -        status = get_identity(session, identity->address, PEP_OWN_USERID,
   2.477 -                &stored_identity);
   2.478 -        if (status == PEP_STATUS_OK) {
   2.479 -            free_identity(stored_identity);
   2.480 -            return _myself(session, identity, false, true);
   2.481 +    if (identity->user_id) {            
   2.482 +        // (we're gonna update the trust/fpr anyway, so we use the no-fpr-from-trust-db variant)
   2.483 +        //      * do get_identity() to retrieve stored identity information
   2.484 +        status = get_identity_without_trust_check(session, identity->address, identity->user_id, &stored_ident);
   2.485 +
   2.486 +        // Before we start - if there was no stored identity, we should check to make sure we don't
   2.487 +        // have a stored identity with a temporary user_id that differs from the input user_id. This
   2.488 +        // happens in multithreaded environments sometimes.
   2.489 +        if (!stored_ident) {
   2.490 +            identity_list* id_list = NULL;
   2.491 +            status = get_identities_by_address(session, identity->address, &id_list);
   2.492 +
   2.493 +            if (id_list) {
   2.494 +                identity_list* id_curr = id_list;
   2.495 +                while (id_curr) {
   2.496 +                    pEp_identity* this_id = id_curr->ident;
   2.497 +                    if (this_id) {
   2.498 +                        char* this_uid = this_id->user_id;
   2.499 +                        if (this_uid && (strstr(this_uid, "TOFU_") == this_uid)) {
   2.500 +                            // FIXME: should we also be fixing pEp_own_userId in this
   2.501 +                            // function here?
   2.502 +                            
   2.503 +                            // if usernames match, we replace the userid. Or if the temp username
   2.504 +                            // is anonymous.
   2.505 +                            if (!this_id->username ||
   2.506 +                                strcasecmp(this_id->username, "anonymous") == 0 ||
   2.507 +                                (identity->username && 
   2.508 +                                 strcasecmp(identity->username, 
   2.509 +                                            this_id->username) == 0)) {
   2.510 +                                
   2.511 +                                // Ok, we have a temp ID. We have to replace this
   2.512 +                                // with the real ID.
   2.513 +                                status = replace_userid(session, 
   2.514 +                                                        this_uid, 
   2.515 +                                                        identity->user_id);
   2.516 +                                if (status != PEP_STATUS_OK) {
   2.517 +                                    free_identity_list(id_list);
   2.518 +                                    return status;
   2.519 +                                }
   2.520 +                                    
   2.521 +                                free(this_uid);
   2.522 +                                this_uid = NULL;
   2.523 +                                
   2.524 +                                // Reflect the change we just made to the DB
   2.525 +                                this_id->user_id = strdup(identity->user_id);
   2.526 +                                stored_ident = this_id;
   2.527 +                                // FIXME: free list.
   2.528 +                                break;                                
   2.529 +                            }                            
   2.530 +                        } 
   2.531 +                    }
   2.532 +                    id_curr = id_curr->next;
   2.533 +                }
   2.534 +            }
   2.535 +        } 
   2.536 +                
   2.537 +        if (status == PEP_STATUS_OK && stored_ident) { 
   2.538 +            //  * if identity available
   2.539 +            //      * patch it with username
   2.540 +            //          (note: this will happen when 
   2.541 +            //           setting automatically below...)
   2.542 +            //      * elect valid key for identity
   2.543 +            //    * if valid key exists
   2.544 +            //        * set return value's fpr
   2.545 +            status = prepare_updated_identity(session,
   2.546 +                                              identity,
   2.547 +                                              stored_ident, true);
   2.548          }
   2.549 +        //  * else (identity unavailable)
   2.550 +        else {
   2.551 +            status = PEP_STATUS_OK;
   2.552 +            
   2.553 +            //  if we only have user_id and address and identity not available
   2.554 +            //      * return error status (identity not found)
   2.555 +            if (!(identity->username))
   2.556 +                status = PEP_CANNOT_FIND_IDENTITY;
   2.557 +            
   2.558 +            // Otherwise, if we had user_id, address, and username:
   2.559 +            //    * create identity with user_id, address, username
   2.560 +            //      (this is the input id without the fpr + comm type!)
   2.561 +            free(identity->fpr);
   2.562 +            identity->fpr = NULL;
   2.563 +            identity->comm_type = PEP_ct_unknown;
   2.564 +            
   2.565 +            //    * We've already checked and retrieved
   2.566 +            //      any applicable temporary identities above. If we're 
   2.567 +            //      here, none of them fit.
   2.568 +            //    * call set_identity() to store
   2.569 +            if (status == PEP_STATUS_OK) {
   2.570 +                status = set_identity(session, identity);
   2.571 +                if (status == PEP_STATUS_OK) {
   2.572 +                    elect_pubkey(session, identity);
   2.573 +                }
   2.574 +            }
   2.575 +            //  * Return: created identity
   2.576 +        }        
   2.577 +    }
   2.578 +    else if (identity->username) {
   2.579 +        /*
   2.580 +         * Temporary identity information with username supplied
   2.581 +            * Input: address, username (no others)
   2.582 +         */
   2.583 +         
   2.584 +        //  * See if there is an own identity that uses this address. If so, we'll
   2.585 +        //    prefer that
   2.586 +        stored_ident = NULL;
   2.587 +        
   2.588 +        if (default_own_id) {
   2.589 +            status = get_identity(session, 
   2.590 +                                  default_own_id, 
   2.591 +                                  identity->address, 
   2.592 +                                  &stored_ident);
   2.593 +        }
   2.594 +        // If there isn't an own identity, search for a non-temp stored ident
   2.595 +        // with this address.                      
   2.596 +        if (status == PEP_CANNOT_FIND_IDENTITY || !stored_ident) { 
   2.597 + 
   2.598 +            identity_list* id_list = NULL;
   2.599 +            status = get_identities_by_address(session, identity->address, &id_list);
   2.600  
   2.601 -        free(identity->user_id);
   2.602 -
   2.603 -        identity->user_id = calloc(1, strlen(identity->address) + 6);
   2.604 -        if (!identity->user_id)
   2.605 -        {
   2.606 -            return PEP_OUT_OF_MEMORY;
   2.607 -        }
   2.608 -        snprintf(identity->user_id, strlen(identity->address) + 6,
   2.609 -                 "TOFU_%s", identity->address);
   2.610 -    }
   2.611 - 
   2.612 -    status = get_identity(session,
   2.613 -                          identity->address,
   2.614 -                          identity->user_id,
   2.615 -                          &stored_identity);
   2.616 -    
   2.617 -    assert(status != PEP_OUT_OF_MEMORY);
   2.618 -    if (status == PEP_OUT_OF_MEMORY)
   2.619 -        goto exit_free;
   2.620 -
   2.621 -    temp_id = identity_dup(identity);
   2.622 -    
   2.623 -    /* We don't take given fpr. 
   2.624 -       In case there's no acceptable stored fpr, it will be elected. */
   2.625 -    free(temp_id->fpr);
   2.626 -    temp_id->fpr = NULL;
   2.627 -    temp_id->comm_type = PEP_ct_unknown;
   2.628 -            
   2.629 -    if (stored_identity) {
   2.630 -        
   2.631 -        bool dont_use_stored_fpr = true;
   2.632 -
   2.633 -        /* if we have a stored_identity fpr */
   2.634 -        if (!EMPTYSTR(stored_identity->fpr)) {
   2.635 -            bool revoked = false;
   2.636 -            status = key_revoked(session, stored_identity->fpr, &revoked);
   2.637 -            
   2.638 -            if (status != PEP_STATUS_OK || revoked)
   2.639 -                dont_use_stored_fpr = true;
   2.640 -                
   2.641 -            if (revoked) {
   2.642 -                // Do stuff
   2.643 -                status = update_trust_for_fpr(session, stored_identity->fpr, PEP_ct_key_revoked);
   2.644 -                // What to do on failure? FIXME
   2.645 -                status = replace_identities_fpr(session, stored_identity->fpr, "");
   2.646 -            }
   2.647 -            else {    
   2.648 -                status = blacklist_is_listed(session, stored_identity->fpr, &dont_use_stored_fpr);
   2.649 -                if (status != PEP_STATUS_OK)
   2.650 -                    dont_use_stored_fpr = true; 
   2.651 -            }
   2.652 -        }
   2.653 -            
   2.654 -
   2.655 -        if (!dont_use_stored_fpr) {
   2.656 -            /* Check stored comm_type */
   2.657 -            PEP_comm_type _comm_type_key;
   2.658 -            status = get_key_rating(session, stored_identity->fpr, &_comm_type_key);
   2.659 -            assert(status != PEP_OUT_OF_MEMORY);
   2.660 -            if (status == PEP_OUT_OF_MEMORY) {
   2.661 -                goto exit_free;
   2.662 -            }
   2.663 -            if (status == PEP_KEY_NOT_FOUND){
   2.664 -                /* stored key was deleted from keyring. any other candidate ?*/
   2.665 -                status = elect_pubkey(session, temp_id);
   2.666 -                if (status != PEP_STATUS_OK) {
   2.667 -                    goto exit_free;
   2.668 -                } else {
   2.669 -                    _did_elect_new_key = 1;
   2.670 -                }
   2.671 -            } else {
   2.672 -                temp_id->fpr = strdup(stored_identity->fpr);
   2.673 -                assert(temp_id->fpr);
   2.674 -                if (temp_id->fpr == NULL) {
   2.675 -                    status = PEP_OUT_OF_MEMORY;
   2.676 -                    goto exit_free;
   2.677 -                }
   2.678 -
   2.679 -                if (_comm_type_key < PEP_ct_unconfirmed_encryption) {
   2.680 -                    /* if key not good anymore, 
   2.681 -                       downgrade eventually trusted comm_type */
   2.682 -                    temp_id->comm_type = _comm_type_key;
   2.683 -                } else {
   2.684 -                    /* otherwise take stored comm_type as-is except if 
   2.685 -                       is unknown or is expired (but key not expired anymore) */
   2.686 -                    temp_id->comm_type = stored_identity->comm_type;
   2.687 -                    if (temp_id->comm_type == PEP_ct_unknown ||
   2.688 -                        temp_id->comm_type == PEP_ct_key_expired) {
   2.689 -                        temp_id->comm_type = _comm_type_key;
   2.690 +            if (id_list) {
   2.691 +                identity_list* id_curr = id_list;
   2.692 +                while (id_curr) {
   2.693 +                    pEp_identity* this_id = id_curr->ident;
   2.694 +                    if (this_id) {
   2.695 +                        char* this_uid = this_id->user_id;
   2.696 +                        if (this_uid && (strstr(this_uid, "TOFU_") != this_uid)) {
   2.697 +                            // if usernames match, we replace the userid.
   2.698 +                            if (identity->username && 
   2.699 +                                strcasecmp(identity->username, 
   2.700 +                                           this_id->username) == 0) {
   2.701 +                                
   2.702 +                                // Ok, we have a real ID. Copy it!
   2.703 +                                identity->user_id = strdup(this_uid);
   2.704 +                                
   2.705 +                                if (!identity->user_id)
   2.706 +                                    status = PEP_OUT_OF_MEMORY;
   2.707 +                                stored_ident = this_id;
   2.708 +                                
   2.709 +                                break;                                
   2.710 +                            }                            
   2.711 +                        } 
   2.712                      }
   2.713 +                    id_curr = id_curr->next;
   2.714                  }
   2.715              }
   2.716          }
   2.717 +        
   2.718 +        if (stored_ident) {
   2.719 +            status = prepare_updated_identity(session,
   2.720 +                                              identity,
   2.721 +                                              stored_ident, true);
   2.722 +        }
   2.723          else {
   2.724 -            status = elect_pubkey(session, temp_id);
   2.725 -            if (status != PEP_STATUS_OK){
   2.726 -                goto exit_free;
   2.727 -            } else {
   2.728 -                _did_elect_new_key = 1;
   2.729 -            }
   2.730 -        }
   2.731 -        
   2.732 -        /* ok, from here on out, use temp_id */
   2.733 -        
   2.734 -        
   2.735 -        /* At this point, we either have a non-blacklisted fpr we can work */
   2.736 -        /* with, or we've got nada.                                        */
   2.737 +            // create temporary identity, store it, and Return this
   2.738 +            // This means TOFU_ user_id
   2.739 +            identity->user_id = calloc(1, strlen(identity->address) + 6);
   2.740 +            if (!identity->user_id)
   2.741 +                return PEP_OUT_OF_MEMORY;
   2.742  
   2.743 -        if (EMPTYSTR(temp_id->fpr)) {
   2.744 -            /* nada : set comm_type accordingly */
   2.745 -            temp_id->comm_type = PEP_ct_key_not_found;
   2.746 -        }
   2.747 -        
   2.748 -        if (EMPTYSTR(temp_id->username)) {
   2.749 -            free(temp_id->username);
   2.750 -            temp_id->username = strdup(stored_identity->username);
   2.751 -            assert(temp_id->username);
   2.752 -            if (temp_id->username == NULL){
   2.753 -                status = PEP_OUT_OF_MEMORY;
   2.754 -                goto exit_free;
   2.755 -            }
   2.756 -        }
   2.757 -
   2.758 -        if (temp_id->lang[0] == 0) {
   2.759 -            temp_id->lang[0] = stored_identity->lang[0];
   2.760 -            temp_id->lang[1] = stored_identity->lang[1];
   2.761 -            temp_id->lang[2] = 0;
   2.762 -        }
   2.763 -
   2.764 -        temp_id->flags = stored_identity->flags;
   2.765 -    }
   2.766 -    else /* stored_identity == NULL */ {
   2.767 -        temp_id->flags = 0;
   2.768 -
   2.769 -        /* We elect a pubkey */
   2.770 -        status = elect_pubkey(session, temp_id);
   2.771 -        if (status != PEP_STATUS_OK)
   2.772 -            goto exit_free;
   2.773 -        
   2.774 -        /* Work with the elected key */
   2.775 -        if (!EMPTYSTR(temp_id->fpr)) {
   2.776 +            snprintf(identity->user_id, strlen(identity->address) + 6,
   2.777 +                     "TOFU_%s", identity->address);        
   2.778              
   2.779 -            PEP_comm_type _comm_type_key = temp_id->comm_type;
   2.780 -            
   2.781 -            _did_elect_new_key = 1;
   2.782 -
   2.783 -            // We don't want to lose a previous trust entry!!!
   2.784 -            status = get_trust(session, temp_id);
   2.785 -
   2.786 -            bool has_trust_status = (status == PEP_STATUS_OK);
   2.787 -
   2.788 -            if (!has_trust_status)
   2.789 -                temp_id->comm_type = _comm_type_key;
   2.790 -        }
   2.791 -    }
   2.792 -
   2.793 -    if (temp_id->fpr == NULL) {
   2.794 -        temp_id->fpr = strdup("");
   2.795 -        if (temp_id->fpr == NULL) {
   2.796 -            status = PEP_OUT_OF_MEMORY;
   2.797 -            goto exit_free;
   2.798 -        }
   2.799 -    }
   2.800 -    
   2.801 -    
   2.802 -    status = PEP_STATUS_OK;
   2.803 -
   2.804 -    if (temp_id->comm_type != PEP_ct_unknown && !EMPTYSTR(temp_id->user_id)) {
   2.805 -
   2.806 -        if (EMPTYSTR(temp_id->username)) { // mitigate
   2.807 -            free(temp_id->username);
   2.808 -            temp_id->username = strdup("anonymous");
   2.809 -            assert(temp_id->username);
   2.810 -            if (temp_id->username == NULL){
   2.811 -                status = PEP_OUT_OF_MEMORY;
   2.812 -                goto exit_free;
   2.813 -            }
   2.814 -        }
   2.815 -
   2.816 -        // Identity doesn't get stored if call was just about checking existing
   2.817 -        // user by address (i.e. no user id given but already stored)
   2.818 -        if (!(_no_user_id && stored_identity) || _did_elect_new_key)
   2.819 -        {
   2.820 -            status = set_identity(session, temp_id);
   2.821 -            assert(status == PEP_STATUS_OK);
   2.822 -            if (status != PEP_STATUS_OK) {
   2.823 -                goto exit_free;
   2.824 +            free(identity->fpr);
   2.825 +            identity->fpr = NULL;
   2.826 +            identity->comm_type = PEP_ct_unknown;
   2.827 +             
   2.828 +            //    * We've already checked and retrieved
   2.829 +            //      any applicable temporary identities above. If we're 
   2.830 +            //      here, none of them fit.
   2.831 +            //    * call set_identity() to store
   2.832 +            status = set_identity(session, identity);
   2.833 +            if (status == PEP_STATUS_OK) {
   2.834 +                elect_pubkey(session, identity);
   2.835              }
   2.836          }
   2.837      }
   2.838 +    else {
   2.839 +        /*
   2.840 +         * Temporary identity information without username suplied
   2.841 +            * Input: address (no others)
   2.842 +         */
   2.843 +         
   2.844 +        //  * Again, see if there is an own identity that uses this address. If so, we'll
   2.845 +        //    prefer that
   2.846 +        stored_ident = NULL;
   2.847 +         
   2.848 +        if (default_own_id) {
   2.849 +            status = get_identity(session, 
   2.850 +                                  default_own_id, 
   2.851 +                                  identity->address, 
   2.852 +                                  &stored_ident);
   2.853 +        }
   2.854 +        // If there isn't an own identity, search for a non-temp stored ident
   2.855 +        // with this address.                      
   2.856 +        if (status == PEP_CANNOT_FIND_IDENTITY || !stored_ident) { 
   2.857 + 
   2.858 +            identity_list* id_list = NULL;
   2.859 +            status = get_identities_by_address(session, identity->address, &id_list);
   2.860  
   2.861 -    if (temp_id->comm_type != PEP_ct_compromized &&
   2.862 -            temp_id->comm_type < PEP_ct_strong_but_unconfirmed)
   2.863 +            //    * Search for identity with this address
   2.864 +            if (id_list && !(id_list->next)) { // exactly one            
   2.865 +                //    * If exactly one found
   2.866 +                //      * elect valid key for identity (see below)
   2.867 +                //      * Return this identity
   2.868 +                stored_ident = id_list->ident;
   2.869 +            }
   2.870 +        }
   2.871 +        if (stored_ident)
   2.872 +            status = prepare_updated_identity(session, identity,
   2.873 +                                              stored_ident, false);
   2.874 +        else // too little info
   2.875 +            status = PEP_CANNOT_FIND_IDENTITY; 
   2.876 +    }
   2.877 +    
   2.878 +    // FIXME: This is legacy. I presume it's a notification for the caller...
   2.879 +    // Revisit once I can talk to Volker
   2.880 +    if (identity->comm_type != PEP_ct_compromized &&
   2.881 +        identity->comm_type < PEP_ct_strong_but_unconfirmed)
   2.882          if (session->examine_identity)
   2.883 -            session->examine_identity(temp_id, session->examine_management);
   2.884 -    
   2.885 -    /* ok, we got to the end. So we can assign the output identity */
   2.886 -    free(identity->address);
   2.887 -    identity->address = strdup(temp_id->address);
   2.888 -    free(identity->fpr);
   2.889 -    identity->fpr = strdup(temp_id->fpr);
   2.890 -    free(identity->user_id);
   2.891 -    identity->user_id = strdup(temp_id->user_id);
   2.892 -    free(identity->username);
   2.893 -    identity->username = strdup(temp_id->username ? temp_id->username : "anonymous");
   2.894 -    identity->comm_type = temp_id->comm_type;
   2.895 -    identity->lang[0] = temp_id->lang[0];
   2.896 -    identity->lang[1] = temp_id->lang[1];
   2.897 -    identity->lang[2] = 0;
   2.898 -    identity->flags = temp_id->flags;
   2.899 +            session->examine_identity(identity, session->examine_management);
   2.900  
   2.901 -exit_free :
   2.902 -    free_identity(stored_identity);
   2.903 -    free_identity(temp_id);
   2.904 -    
   2.905      return ADD_TO_LOG(status);
   2.906  }
   2.907  
   2.908 @@ -418,206 +774,189 @@
   2.909  
   2.910  PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen, bool ignore_flags)
   2.911  {
   2.912 -    pEp_identity *stored_identity = NULL;
   2.913 +
   2.914      PEP_STATUS status;
   2.915  
   2.916      assert(session);
   2.917      assert(identity);
   2.918      assert(!EMPTYSTR(identity->address));
   2.919 +    assert(!EMPTYSTR(identity->user_id));
   2.920  
   2.921 -    assert(EMPTYSTR(identity->user_id) ||
   2.922 -           strcmp(identity->user_id, PEP_OWN_USERID) == 0);
   2.923 -
   2.924 -    if (!(session && identity && !EMPTYSTR(identity->address) &&
   2.925 -            (EMPTYSTR(identity->user_id) ||
   2.926 -            strcmp(identity->user_id, PEP_OWN_USERID) == 0)))
   2.927 +    if (!session || !identity || EMPTYSTR(identity->address) ||
   2.928 +        EMPTYSTR(identity->user_id))
   2.929          return ADD_TO_LOG(PEP_ILLEGAL_VALUE);
   2.930  
   2.931 +    pEp_identity *stored_identity = NULL;
   2.932 +    char* revoked_fpr = NULL; 
   2.933 +        
   2.934 +    char* default_own_id = NULL;
   2.935 +    status = get_default_own_userid(session, &default_own_id);
   2.936 +
   2.937 +    // Deal with non-default user_ids.
   2.938 +    if (default_own_id && strcmp(default_own_id, identity->user_id) != 0) {
   2.939 +        
   2.940 +        status = set_userid_alias(session, default_own_id, identity->user_id);
   2.941 +        // Do we want this to be fatal? For now, we'll do it...
   2.942 +        if (status != PEP_STATUS_OK)
   2.943 +            goto pep_free;
   2.944 +            
   2.945 +        free(identity->user_id);
   2.946 +        identity->user_id = strdup(default_own_id);
   2.947 +        if (identity->user_id == NULL) {
   2.948 +            status = PEP_OUT_OF_MEMORY;
   2.949 +            goto pep_free;
   2.950 +        }
   2.951 +    }
   2.952 +
   2.953 +    // NOTE: IF WE DON'T YET HAVE AN OWN_ID, WE IGNORE REFERENCES TO THIS ADDRESS IN THE
   2.954 +    // DB (WHICH MAY HAVE BEEN SET BEFORE MYSELF WAS CALLED BY RECEIVING AN EMAIL FROM
   2.955 +    // THIS ADDRESS), AS IT IS NOT AN OWN_IDENTITY AND HAS NO INFORMATION WE NEED OR WHAT TO
   2.956 +    // SET FOR MYSELF
   2.957 +    
   2.958 +    // Ok, so now, set up the own_identity:
   2.959      identity->comm_type = PEP_ct_pEp;
   2.960 +    identity->me = true;
   2.961      if(ignore_flags)
   2.962          identity->flags = 0;
   2.963      
   2.964 -    if (EMPTYSTR(identity->user_id))
   2.965 -    {
   2.966 -        free(identity->user_id);
   2.967 -        identity->user_id = strdup(PEP_OWN_USERID);
   2.968 -        assert(identity->user_id);
   2.969 -        if (identity->user_id == NULL)
   2.970 -            return PEP_OUT_OF_MEMORY;
   2.971 -    }
   2.972 -
   2.973 -    if (EMPTYSTR(identity->username))
   2.974 -    {
   2.975 -        free(identity->username);
   2.976 -        identity->username = strdup("anonymous");
   2.977 -        assert(identity->username);
   2.978 -        if (identity->username == NULL)
   2.979 -            return PEP_OUT_OF_MEMORY;
   2.980 -    }
   2.981 -
   2.982 +    // Let's see if we have an identity record in the DB for 
   2.983 +    // this user_id + address
   2.984      DEBUG_LOG("myself", "debug", identity->address);
   2.985   
   2.986      status = get_identity(session,
   2.987                            identity->address,
   2.988                            identity->user_id,
   2.989                            &stored_identity);
   2.990 -    
   2.991 +
   2.992      assert(status != PEP_OUT_OF_MEMORY);
   2.993      if (status == PEP_OUT_OF_MEMORY)
   2.994          return PEP_OUT_OF_MEMORY;
   2.995  
   2.996 -    bool dont_use_stored_fpr = true;
   2.997 -    bool dont_use_input_fpr = true;
   2.998 +    // Set usernames - priority is input username > stored name > "Anonymous"
   2.999 +    // If there's an input username, we always patch the username with that
  2.1000 +    // input.
  2.1001 +    if (EMPTYSTR(identity->username)) {
  2.1002 +        bool stored_uname = (stored_identity && stored_identity->username);
  2.1003 +        char* uname = (stored_uname ? stored_identity->username : "Anonymous");
  2.1004 +        free(identity->username);
  2.1005 +        identity->username = strdup(uname);
  2.1006 +        if (identity->username == NULL)
  2.1007 +            return PEP_OUT_OF_MEMORY;
  2.1008 +    }
  2.1009 +
  2.1010 +    bool valid_key_found = false;
  2.1011 +    
  2.1012 +    // Now deal with keys.
  2.1013 +    // Different from update_identity(), the input fpr here
  2.1014 +    // MATTERS. 
  2.1015 +    // If the input fpr is invalid, we return, giving the reason why.
  2.1016 +    if (identity->fpr) {
  2.1017 +        status = validate_fpr(session, identity);
  2.1018 +    
  2.1019 +        if (status != PEP_STATUS_OK || 
  2.1020 +            identity->comm_type < PEP_ct_strong_but_unconfirmed) {
  2.1021 +            if (identity->comm_type != PEP_ct_key_expired)
  2.1022 +                goto pep_free;
  2.1023 +            // Otherwise, it was expired and key renewal failed
  2.1024 +            // and we take the stored one or do keygen. 
  2.1025 +        } 
  2.1026 +        else
  2.1027 +            valid_key_found = true;
  2.1028 +    }    
  2.1029 +    
  2.1030 +    // Ok, if there wasn't a valid input fpr, check stored identity
  2.1031 +    if (!valid_key_found && stored_identity && 
  2.1032 +        (!identity->fpr || strcmp(stored_identity->fpr, identity->fpr) != 0)) {
  2.1033          
  2.1034 -    if (stored_identity)
  2.1035 -    {
  2.1036 -        if (EMPTYSTR(identity->fpr)) {
  2.1037 -            
  2.1038 -            bool has_private = false;
  2.1039 -            
  2.1040 -            status = _has_usable_priv_key(session, stored_identity->fpr, &has_private); 
  2.1041 -            
  2.1042 -            // N.B. has_private is never true if the returned status is not PEP_STATUS_OK
  2.1043 -            if (has_private) {
  2.1044 -                identity->fpr = strdup(stored_identity->fpr);
  2.1045 -                assert(identity->fpr);
  2.1046 -                if (identity->fpr == NULL)
  2.1047 -                {
  2.1048 -                    return PEP_OUT_OF_MEMORY;
  2.1049 -                }
  2.1050 -                dont_use_stored_fpr = false;
  2.1051 -            }
  2.1052 +        // Fall back / retrieve
  2.1053 +        status = validate_fpr(session, stored_identity);
  2.1054 +        if (status == PEP_STATUS_OK && 
  2.1055 +            stored_identity->comm_type >= PEP_ct_strong_but_unconfirmed) {
  2.1056 +          
  2.1057 +            free(identity->fpr);
  2.1058 +            identity->fpr = strdup(stored_identity->fpr);
  2.1059 +            valid_key_found = true;            
  2.1060          }
  2.1061 -        
  2.1062 -        identity->flags = (identity->flags & 255) | stored_identity->flags;
  2.1063 -        free_identity(stored_identity);
  2.1064 -    }
  2.1065 -    
  2.1066 -    if (dont_use_stored_fpr && !EMPTYSTR(identity->fpr))
  2.1067 -    {
  2.1068 -        // App must have a good reason to give fpr, such as explicit
  2.1069 -        // import of private key, or similar.
  2.1070 -
  2.1071 -        // Take given fpr as-is.
  2.1072 -
  2.1073 -        // BUT:
  2.1074 -        // First check to see if it's blacklisted or private part is missing?
  2.1075 -        bool has_private = false;
  2.1076 -        
  2.1077 -        status = _has_usable_priv_key(session, identity->fpr, &has_private); 
  2.1078 -        
  2.1079 -        // N.B. has_private is never true if the returned status is not PEP_STATUS_OK
  2.1080 -        if (has_private) {
  2.1081 -            dont_use_input_fpr = false;
  2.1082 +        else {
  2.1083 +            bool revoked = false;
  2.1084 +            if (!EMPTYSTR(stored_identity->fpr)) {
  2.1085 +                status = key_revoked(session, stored_identity->fpr, &revoked);
  2.1086 +                if (revoked)
  2.1087 +                    revoked_fpr = strdup(stored_identity->fpr);
  2.1088 +            }        
  2.1089          }
  2.1090      }
  2.1091      
  2.1092 -    // Ok, we failed to get keys either way, so let's elect one.
  2.1093 -    if (dont_use_input_fpr && dont_use_stored_fpr)
  2.1094 -    {
  2.1095 -        status = elect_ownkey(session, identity);
  2.1096 -        assert(status == PEP_STATUS_OK);
  2.1097 -        if (status != PEP_STATUS_OK) {
  2.1098 -            return ADD_TO_LOG(status);
  2.1099 -        }
  2.1100 +    // Nothing left to do but generate a key
  2.1101 +    if (!valid_key_found) {
  2.1102 +        if (!do_keygen)
  2.1103 +            status = PEP_GET_KEY_FAILED;
  2.1104 +        else {
  2.1105 +            DEBUG_LOG("Generating key pair", "debug", identity->address);
  2.1106  
  2.1107 -        bool has_private = false;
  2.1108 -        if (identity->fpr) {
  2.1109 -            // ok, we elected something.
  2.1110 -            // elect_ownkey only returns private keys, so we don't check again.
  2.1111 -            // Check to see if it's blacklisted
  2.1112 -            bool listed;
  2.1113 -            status = blacklist_is_listed(session, identity->fpr, &listed); 
  2.1114 +            free(identity->fpr);
  2.1115 +            identity->fpr = NULL;
  2.1116 +            status = generate_keypair(session, identity);
  2.1117 +            assert(status != PEP_OUT_OF_MEMORY);
  2.1118  
  2.1119 -            if (status == PEP_STATUS_OK)
  2.1120 -                has_private = !listed;
  2.1121 -        }
  2.1122 -        
  2.1123 -        if (has_private) {
  2.1124 -            dont_use_input_fpr = false;
  2.1125 -        }
  2.1126 -        else { // OK, we've tried everything. Time to generate new keys.
  2.1127 -            free(identity->fpr); // It can stay in this state (unallocated) because we'll generate a new key 
  2.1128 -            identity->fpr = NULL;
  2.1129 +            if (status != PEP_STATUS_OK) {
  2.1130 +                char buf[11];
  2.1131 +                snprintf(buf, 11, "%d", status); // uh, this is kludgey. FIXME
  2.1132 +                DEBUG_LOG("Generating key pair failed", "debug", buf);
  2.1133 +            }        
  2.1134 +            else {
  2.1135 +                valid_key_found = true;
  2.1136 +                if (revoked_fpr) {
  2.1137 +                    status = set_revoked(session, revoked_fpr,
  2.1138 +                                         stored_identity->fpr, time(NULL));
  2.1139 +                }
  2.1140 +            }
  2.1141          }
  2.1142      }
  2.1143  
  2.1144 -    bool revoked = false;
  2.1145 -    char *r_fpr = NULL;
  2.1146 -    if (!EMPTYSTR(identity->fpr))
  2.1147 -    {
  2.1148 -        status = key_revoked(session, identity->fpr, &revoked);
  2.1149 +    if (valid_key_found) {
  2.1150 +        identity->comm_type = PEP_ct_pEp;
  2.1151 +        status = PEP_STATUS_OK;
  2.1152 +    }
  2.1153 +    else {
  2.1154 +        free(identity->fpr);
  2.1155 +        identity->fpr = NULL;
  2.1156 +        identity->comm_type = PEP_ct_unknown;
  2.1157 +    }
  2.1158 +    
  2.1159 +    status = set_identity(session, identity);
  2.1160  
  2.1161 -        if (status != PEP_STATUS_OK) 
  2.1162 -        {
  2.1163 -            return ADD_TO_LOG(status);
  2.1164 -        }
  2.1165 -    }
  2.1166 -   
  2.1167 -    if (EMPTYSTR(identity->fpr) || revoked)
  2.1168 -    {
  2.1169 -        if(!do_keygen){
  2.1170 -            return ADD_TO_LOG(PEP_GET_KEY_FAILED);
  2.1171 +pep_free:    
  2.1172 +    free(default_own_id);
  2.1173 +    free(revoked_fpr);                     
  2.1174 +    free_identity(stored_identity);
  2.1175 +    return ADD_TO_LOG(status);
  2.1176 +}
  2.1177 +
  2.1178 +DYNAMIC_API PEP_STATUS initialise_own_identities(PEP_SESSION session,
  2.1179 +                                                 identity_list* my_idents) {
  2.1180 +    PEP_STATUS status = PEP_STATUS_OK;
  2.1181 +    if (!session)
  2.1182 +        return PEP_ILLEGAL_VALUE;
  2.1183 +        
  2.1184 +    if (!my_idents)
  2.1185 +        return PEP_STATUS_OK;
  2.1186 +            
  2.1187 +    identity_list* ident_curr = my_idents;
  2.1188 +    while (ident_curr) {
  2.1189 +        pEp_identity* ident = ident_curr->ident;
  2.1190 +        if (!ident || !ident->address) {
  2.1191 +            status = PEP_ILLEGAL_VALUE;
  2.1192 +            goto pep_error;
  2.1193          }
  2.1194  
  2.1195 -        if(revoked)
  2.1196 -        {
  2.1197 -            r_fpr = identity->fpr;
  2.1198 -            identity->fpr = NULL;
  2.1199 -        }
  2.1200 +        status = _myself(session, ident, false, false);
  2.1201          
  2.1202 -        DEBUG_LOG("generating key pair", "debug", identity->address);
  2.1203 -        status = generate_keypair(session, identity);
  2.1204 -        assert(status != PEP_OUT_OF_MEMORY);
  2.1205 -        if (status != PEP_STATUS_OK) {
  2.1206 -            char buf[11];
  2.1207 -            snprintf(buf, 11, "%d", status);
  2.1208 -            DEBUG_LOG("generating key pair failed", "debug", buf);
  2.1209 -            if(revoked && r_fpr)
  2.1210 -                free(r_fpr);
  2.1211 -            return ADD_TO_LOG(status);
  2.1212 -        }
  2.1213 -
  2.1214 -        
  2.1215 -        if(revoked)
  2.1216 -        {
  2.1217 -            status = set_revoked(session, r_fpr,
  2.1218 -                                 identity->fpr, time(NULL));
  2.1219 -            free(r_fpr);
  2.1220 -            if (status != PEP_STATUS_OK) {
  2.1221 -                return ADD_TO_LOG(status);
  2.1222 -            }
  2.1223 -        }
  2.1224 +        ident_curr = ident_curr->next;
  2.1225      }
  2.1226 -    else
  2.1227 -    {
  2.1228 -        bool expired;
  2.1229 -        status = key_expired(session, identity->fpr, 
  2.1230 -                             time(NULL) + (7*24*3600), // In a week
  2.1231 -                             &expired);
  2.1232 -
  2.1233 -        assert(status == PEP_STATUS_OK);
  2.1234 -        if (status != PEP_STATUS_OK) {
  2.1235 -            return ADD_TO_LOG(status);
  2.1236 -        }
  2.1237 -
  2.1238 -        if (status == PEP_STATUS_OK && expired) {
  2.1239 -            timestamp *ts = new_timestamp(time(NULL) + KEY_EXPIRE_DELTA);
  2.1240 -            renew_key(session, identity->fpr, ts);
  2.1241 -            free_timestamp(ts);
  2.1242 -        }
  2.1243 -    }
  2.1244 -
  2.1245 -    if (!identity->username)
  2.1246 -        identity->username = strdup("");
  2.1247      
  2.1248 -    status = set_identity(session, identity);
  2.1249 -    assert(status == PEP_STATUS_OK);
  2.1250 -    if (status != PEP_STATUS_OK) {
  2.1251 -        return status;
  2.1252 -    }
  2.1253 -
  2.1254 -    return ADD_TO_LOG(PEP_STATUS_OK);
  2.1255 +pep_error:
  2.1256 +    return status;
  2.1257  }
  2.1258  
  2.1259  DYNAMIC_API PEP_STATUS myself(PEP_SESSION session, pEp_identity * identity)
  2.1260 @@ -670,7 +1009,7 @@
  2.1261          {
  2.1262              DEBUG_LOG("do_keymanagement", "retrieve_next_identity", identity->address);
  2.1263  
  2.1264 -            if (_identity_me(identity)) {
  2.1265 +            if (identity->me) {
  2.1266                  status = myself(session, identity);
  2.1267              } else {
  2.1268                  status = recv_key(session, identity->address);
  2.1269 @@ -703,7 +1042,7 @@
  2.1270      if (!(session && ident && ident->fpr))
  2.1271          return PEP_ILLEGAL_VALUE;
  2.1272  
  2.1273 -    if (_identity_me(ident))
  2.1274 +    if (ident->me)
  2.1275      {
  2.1276          revoke_key(session, ident->fpr, NULL);
  2.1277          myself(session, ident);
  2.1278 @@ -751,12 +1090,12 @@
  2.1279  
  2.1280      assert(session);
  2.1281      assert(ident);
  2.1282 -    assert(!_identity_me(ident));
  2.1283 +    assert(!ident->me);
  2.1284      assert(!EMPTYSTR(ident->fpr));
  2.1285      assert(!EMPTYSTR(ident->address));
  2.1286      assert(!EMPTYSTR(ident->user_id));
  2.1287  
  2.1288 -    if (!(session && ident && !_identity_me(ident) && ident->fpr && ident->address &&
  2.1289 +    if (!(session && ident && !ident->me && ident->fpr && ident->address &&
  2.1290              ident->user_id))
  2.1291          return PEP_ILLEGAL_VALUE;
  2.1292  
  2.1293 @@ -837,6 +1176,7 @@
  2.1294          case SQLITE_ROW:
  2.1295              count = sqlite3_column_int(session->own_key_is_listed, 0);
  2.1296              *listed = count > 0;
  2.1297 +            status = PEP_STATUS_OK;
  2.1298              break;
  2.1299              
  2.1300          default:
  2.1301 @@ -886,14 +1226,15 @@
  2.1302                      sqlite3_column_text(session->own_identities_retrieve, 0);
  2.1303                  fpr = (const char *)
  2.1304                      sqlite3_column_text(session->own_identities_retrieve, 1);
  2.1305 -                user_id = PEP_OWN_USERID;
  2.1306 +                user_id = (const char *)
  2.1307 +                    sqlite3_column_text(session->own_identities_retrieve, 2);
  2.1308                  username = (const char *)
  2.1309 -                    sqlite3_column_text(session->own_identities_retrieve, 2);
  2.1310 +                    sqlite3_column_text(session->own_identities_retrieve, 3);
  2.1311                  comm_type = PEP_ct_pEp;
  2.1312                  lang = (const char *)
  2.1313 -                    sqlite3_column_text(session->own_identities_retrieve, 3);
  2.1314 +                    sqlite3_column_text(session->own_identities_retrieve, 4);
  2.1315                  flags = (unsigned int)
  2.1316 -                    sqlite3_column_int(session->own_identities_retrieve, 4);
  2.1317 +                    sqlite3_column_int(session->own_identities_retrieve, 5);
  2.1318  
  2.1319                  pEp_identity *ident = new_identity(address, fpr, user_id, username);
  2.1320                  if (!ident)
  2.1321 @@ -904,6 +1245,7 @@
  2.1322                      ident->lang[1] = lang[1];
  2.1323                      ident->lang[2] = 0;
  2.1324                  }
  2.1325 +                ident->me = true;
  2.1326                  ident->flags = flags;
  2.1327  
  2.1328                  _bl = identity_list_add(_bl, ident);
  2.1329 @@ -1036,24 +1378,50 @@
  2.1330            fpr && fpr[0]
  2.1331           ))
  2.1332          return PEP_ILLEGAL_VALUE;
  2.1333 -    
  2.1334 -    sqlite3_reset(session->set_own_key);
  2.1335 -    sqlite3_bind_text(session->set_own_key, 1, address, -1, SQLITE_STATIC);
  2.1336 -    sqlite3_bind_text(session->set_own_key, 2, fpr, -1, SQLITE_STATIC);
  2.1337 -
  2.1338 -    int result;
  2.1339 -    
  2.1340 -    result = sqlite3_step(session->set_own_key);
  2.1341 -    switch (result) {
  2.1342 -        case SQLITE_DONE:
  2.1343 -            status = PEP_STATUS_OK;
  2.1344 -            break;
  2.1345 -            
  2.1346 -        default:
  2.1347 -            status = PEP_UNKNOWN_ERROR;
  2.1348 +                        
  2.1349 +    // First see if we have it in own identities already, AND we retrieve
  2.1350 +    // our own user_id
  2.1351 +    char* my_user_id = NULL;
  2.1352 +    status = get_default_own_userid(session, &my_user_id);
  2.1353 +    if (status != PEP_STATUS_OK)
  2.1354 +        return status;
  2.1355 +        
  2.1356 +    if (!my_user_id) {
  2.1357 +        // We have no own user_id. So we cannot set it for an identity.
  2.1358 +        return PEP_CANNOT_FIND_IDENTITY;
  2.1359      }
  2.1360      
  2.1361 -    sqlite3_reset(session->set_own_key);
  2.1362 +    pEp_identity* my_id = NULL;
  2.1363 +    
  2.1364 +    status = get_identity(session, my_user_id, address, &my_id);
  2.1365 +
  2.1366 +    if (status == PEP_STATUS_OK && my_id) {
  2.1367 +        if (my_id->fpr && strcasecmp(my_id->fpr, fpr) == 0) {
  2.1368 +            // We're done. It was already here.
  2.1369 +            goto pep_free;
  2.1370 +        }           
  2.1371 +    }
  2.1372 +                
  2.1373 +    // If there's an id w/ user_id + address
  2.1374 +    if (my_id) {
  2.1375 +        free(my_id->fpr);
  2.1376 +        my_id->fpr = my_user_id;
  2.1377 +        my_id->comm_type = PEP_ct_pEp;
  2.1378 +        my_id->me = true;
  2.1379 +    }
  2.1380 +    else { // Else, we need a new identity
  2.1381 +        my_id = new_identity(address, fpr, my_user_id, NULL); 
  2.1382 +        if (status != PEP_STATUS_OK)
  2.1383 +            goto pep_free; 
  2.1384 +        my_id->me = true;
  2.1385 +        my_id->comm_type = PEP_ct_pEp;
  2.1386 +    }
  2.1387 +        
  2.1388 +    status = set_identity(session, my_id);
  2.1389 +    
  2.1390 +pep_free:
  2.1391 +    free(my_id);
  2.1392 +    free(my_user_id);
  2.1393      return status;
  2.1394  }
  2.1395  
     3.1 --- a/src/keymanagement.h	Wed Jan 17 11:16:22 2018 +0100
     3.2 +++ b/src/keymanagement.h	Thu Jan 18 00:46:19 2018 +0100
     3.3 @@ -34,13 +34,40 @@
     3.4          PEP_SESSION session, pEp_identity * identity
     3.5      );
     3.6  
     3.7 +// initialise_own_identities () - ensures that an own identity is complete
     3.8 +//
     3.9 +//  parameters:
    3.10 +//      session (in)        session to use
    3.11 +//      my_idents (inout)   identities of local user to quick-set
    3.12 +//                          For these, at least .address must be set.
    3.13 +//                          if no .user_id is set, AND the DB doesn't contain
    3.14 +//                          a default user_id, PEP_OWN_USERID will be used and
    3.15 +//                          become the perennial default for the DB.
    3.16 +//
    3.17 +//  return value:
    3.18 +//      PEP_STATUS_OK if identity could be set,
    3.19 +//      any other value on error
    3.20 +//
    3.21 +//  caveat:
    3.22 +//      this function does NOT generate keypairs. It is intended to
    3.23 +//      precede running of the engine on actual messages. It effectively
    3.24 +//      behaves like myself(), but when there would normally be key generation
    3.25 +//      (when there is no valid key, for example),
    3.26 +//      it instead stores an identity without keys.
    3.27 +//
    3.28 +DYNAMIC_API PEP_STATUS initialise_own_identities(PEP_SESSION session,
    3.29 +                                                 identity_list* my_idents);
    3.30  
    3.31 -// myself() - ensures that the own identity is being complete
    3.32 +// myself() - ensures that an own identity is complete
    3.33  //
    3.34  //  parameters:
    3.35  //      session (in)        session to use
    3.36  //      identity (inout)    identity of local user
    3.37 -//                          at least .address, .username, .user_id must be set
    3.38 +//                          at least .address must be set.
    3.39 +//                          if no .user_id is set, AND the DB doesn't contain
    3.40 +//                          a user_id, PEP_OWN_USERID will be used.
    3.41 +//                          if no .username is set and none is in the DB,
    3.42 +//                          username will be set to "Anonymous"
    3.43  //
    3.44  //  return value:
    3.45  //      PEP_STATUS_OK if identity could be completed or was already complete,
    3.46 @@ -263,6 +290,8 @@
    3.47         const char *fpr
    3.48      );
    3.49  
    3.50 +PEP_STATUS _myself(PEP_SESSION session, pEp_identity * identity, bool do_keygen, bool ignore_flags);
    3.51 +
    3.52  #ifdef __cplusplus
    3.53  }
    3.54  #endif
     4.1 --- a/src/message_api.c	Wed Jan 17 11:16:22 2018 +0100
     4.2 +++ b/src/message_api.c	Thu Jan 18 00:46:19 2018 +0100
     4.3 @@ -920,6 +920,30 @@
     4.4      return NULL;    
     4.5  }
     4.6  
     4.7 +static PEP_STATUS update_identity_recip_list(PEP_SESSION session,
     4.8 +                                             identity_list* list) {
     4.9 +
    4.10 +    PEP_STATUS status = PEP_STATUS_OK;
    4.11 +
    4.12 +    if (!session)
    4.13 +        return PEP_UNKNOWN_ERROR;
    4.14 +    
    4.15 +    identity_list* id_list_ptr = NULL;
    4.16 +        
    4.17 +    for (id_list_ptr = list; id_list_ptr; id_list_ptr = id_list_ptr->next) {
    4.18 +        pEp_identity* curr_identity = id_list_ptr->ident;
    4.19 +        if (curr_identity) {
    4.20 +            status = update_identity(session, curr_identity);
    4.21 +        if (status == PEP_ILLEGAL_VALUE || status == PEP_OUT_OF_MEMORY)
    4.22 +            return status;
    4.23 +        }
    4.24 +        else
    4.25 +            break;
    4.26 +    }
    4.27 +    
    4.28 +    return PEP_STATUS_OK;                                  
    4.29 +}
    4.30 +
    4.31  static PEP_STATUS encrypt_PGP_MIME(
    4.32      PEP_SESSION session,
    4.33      const message *src,
    4.34 @@ -1433,6 +1457,15 @@
    4.35  
    4.36      *dst = NULL;
    4.37  
    4.38 +    if (src->from && (!src->from->user_id || src->from->user_id[0] == '\0')) {
    4.39 +        char* own_id = NULL;
    4.40 +        status = get_default_own_userid(session, &own_id);
    4.41 +        if (own_id) {
    4.42 +            free(src->from->user_id);
    4.43 +            src->from->user_id = own_id; // ownership transfer
    4.44 +        }
    4.45 +    }
    4.46 +    
    4.47      status = myself(session, src->from);
    4.48      if (status != PEP_STATUS_OK)
    4.49          GOTO(pep_error);
    4.50 @@ -1659,18 +1692,26 @@
    4.51      if (src->enc_format != PEP_enc_none)
    4.52          return ADD_TO_LOG(PEP_ILLEGAL_VALUE);
    4.53  
    4.54 +    if (target_id && (!target_id->user_id || target_id->user_id[0] == '\0')) {
    4.55 +        char* own_id = NULL;
    4.56 +        status = get_default_own_userid(session, &own_id);
    4.57 +        if (own_id) {
    4.58 +            free(target_id->user_id);
    4.59 +            target_id->user_id = own_id; // ownership transfer
    4.60 +        }
    4.61 +    }
    4.62 +
    4.63      status = myself(session, target_id);
    4.64      if (status != PEP_STATUS_OK)
    4.65          GOTO(pep_error);
    4.66  
    4.67      *dst = NULL;
    4.68  
    4.69 -
    4.70 -    PEP_STATUS _status = update_identity(session, target_id);
    4.71 -    if (_status != PEP_STATUS_OK) {
    4.72 -        status = _status;
    4.73 -        goto pep_error;
    4.74 -    }
    4.75 +    // PEP_STATUS _status = update_identity(session, target_id);
    4.76 +    // if (_status != PEP_STATUS_OK) {
    4.77 +    //     status = _status;
    4.78 +    //     goto pep_error;
    4.79 +    // }
    4.80  
    4.81      char* target_fpr = target_id->fpr;
    4.82      if (!target_fpr)
    4.83 @@ -1749,6 +1790,7 @@
    4.84      )
    4.85  {
    4.86      PEP_STATUS status;
    4.87 +
    4.88      if (src->from && src->from->address) {
    4.89          status = update_identity(session, src->from);
    4.90          if (status == PEP_STATUS_OK
    4.91 @@ -1958,11 +2000,16 @@
    4.92                  return PEP_OUT_OF_MEMORY;
    4.93  
    4.94              status = get_trust(session, _sender);
    4.95 +            if (_sender->comm_type == PEP_ct_unknown) {
    4.96 +                get_key_rating(session, fpr, &_sender->comm_type);
    4.97 +                
    4.98 +            }
    4.99              if (_sender->comm_type != PEP_ct_unknown) {
   4.100                  *rating = keylist_rating(session, recipients, 
   4.101                              fpr, _rating(_sender->comm_type, 
   4.102                                            PEP_rating_undefined));
   4.103              }
   4.104 +            
   4.105              free_identity(_sender);
   4.106              if (status == PEP_CANNOT_FIND_IDENTITY)
   4.107                 status = PEP_STATUS_OK;
   4.108 @@ -2304,14 +2351,37 @@
   4.109          _private_il->ident->address)
   4.110          *imported_private = true;
   4.111  
   4.112 -    if (private_il && imported_private)
   4.113 +    if (private_il && imported_private) {
   4.114 +        // the private identity list should NOT be subject to myself() or
   4.115 +        // update_identity() at this point.
   4.116 +        // If the receiving app wants them to be in the trust DB, it
   4.117 +        // should call myself() on them upon return.
   4.118 +        // We do, however, prepare these so the app can use them
   4.119 +        // directly in a myself() call by putting the own_id on it.
   4.120 +        char* own_id = NULL;
   4.121 +        status = get_default_own_userid(session, &own_id);
   4.122 +        
   4.123 +        if (status != PEP_STATUS_OK) {
   4.124 +            free(own_id);
   4.125 +            own_id = NULL;
   4.126 +        }
   4.127 +        
   4.128 +        identity_list* il = _private_il;
   4.129 +        for ( ; il; il = il->next) {
   4.130 +            if (own_id) {
   4.131 +                free(il->ident->user_id);
   4.132 +                il->ident->user_id = strdup(own_id);
   4.133 +            }
   4.134 +            il->ident->me = true;
   4.135 +        }
   4.136          *private_il = _private_il;
   4.137 +        
   4.138 +        free(own_id);
   4.139 +    }
   4.140      else
   4.141          free_identity_list(_private_il);
   4.142 -
   4.143 -    if (imported_keys)
   4.144 -        status = _update_identity_for_incoming_message(session, src);
   4.145 -        
   4.146 + 
   4.147 +    
   4.148      return status;
   4.149  }
   4.150  
   4.151 @@ -2361,7 +2431,18 @@
   4.152      // Update src->from in case we just imported a key
   4.153      // we would need to check signature
   4.154      status = _update_identity_for_incoming_message(session, src);
   4.155 -    if(status != PEP_STATUS_OK)
   4.156 +    
   4.157 +    if (status == PEP_ILLEGAL_VALUE && src->from && is_me(session, src->from)) {
   4.158 +        // the above function should fail if it's us.
   4.159 +        // We don't need to update, as any revocations or expirations
   4.160 +        // of our own key imported above, which are all that we 
   4.161 +        // would care about for anything imported,
   4.162 +        // SHOULD get caught when they matter later.
   4.163 +        // (Private keys imported above are not stored in the trust DB)
   4.164 +        status = PEP_STATUS_OK;
   4.165 +    }
   4.166 +        
   4.167 +    if (status != PEP_STATUS_OK)
   4.168          return ADD_TO_LOG(status);
   4.169  
   4.170      /*** End Import any attached public keys and update identities accordingly ***/
   4.171 @@ -2579,8 +2660,7 @@
   4.172      // 1. Check to see if this message is to us and contains an own key imported 
   4.173      // from own trusted message 
   4.174      if (msg && *rating >= PEP_rating_trusted && imported_private_key_address &&
   4.175 -        msg->to->ident->user_id &&
   4.176 -        strcmp(msg->to->ident->user_id, PEP_OWN_USERID) == 0) {
   4.177 +        msg->to && msg->to->ident && msg->to->ident->me) {
   4.178  
   4.179          // flag it as such
   4.180          *flags |= PEP_decrypt_flag_own_private_key;
   4.181 @@ -2749,7 +2829,7 @@
   4.182      if (!(session && ident && rating))
   4.183          return PEP_ILLEGAL_VALUE;
   4.184  
   4.185 -    if (_identity_me(ident))
   4.186 +    if (ident->me)
   4.187          status = _myself(session, ident, false, true);
   4.188      else
   4.189          status = update_identity(session, ident);
   4.190 @@ -3123,6 +3203,28 @@
   4.191      if (status != PEP_STATUS_OK)
   4.192          GOTO(pep_error);
   4.193  
   4.194 +    // MIME decode message delivers only addresses. We need more.
   4.195 +    if (tmp_msg->from) {
   4.196 +        status = update_identity(session, tmp_msg->from);
   4.197 +        if (status == PEP_ILLEGAL_VALUE || status == PEP_OUT_OF_MEMORY)
   4.198 +            GOTO(pep_error);
   4.199 +    }
   4.200 +
   4.201 +    // Own identities can be retrieved here where they would otherwise
   4.202 +    // fail because we lack all other information. This is ok and even
   4.203 +    // desired. FIXME: IS it?
   4.204 +    status = update_identity_recip_list(session, tmp_msg->to);
   4.205 +    if (status != PEP_STATUS_OK)
   4.206 +        GOTO(pep_error);
   4.207 +
   4.208 +    status = update_identity_recip_list(session, tmp_msg->cc);
   4.209 +    if (status != PEP_STATUS_OK)
   4.210 +        GOTO(pep_error);
   4.211 +
   4.212 +    status = update_identity_recip_list(session, tmp_msg->bcc);
   4.213 +    if (status != PEP_STATUS_OK)
   4.214 +        GOTO(pep_error);
   4.215 +
   4.216      PEP_STATUS decrypt_status = decrypt_message(session,
   4.217                                                  tmp_msg,
   4.218                                                  &dec_msg,
   4.219 @@ -3176,6 +3278,39 @@
   4.220      if (status != PEP_STATUS_OK)
   4.221          GOTO(pep_error);
   4.222  
   4.223 +    // MIME decode message delivers only addresses. We need more.
   4.224 +    if (tmp_msg->from) {
   4.225 +        char* own_id = NULL;
   4.226 +        status = get_default_own_userid(session, &own_id);
   4.227 +        free(tmp_msg->from->user_id);
   4.228 +        
   4.229 +        if (status != PEP_STATUS_OK || !own_id) {
   4.230 +            tmp_msg->from->user_id = strdup(PEP_OWN_USERID);
   4.231 +        }
   4.232 +        else {
   4.233 +            tmp_msg->from->user_id = own_id; // ownership transfer
   4.234 +        }
   4.235 +            
   4.236 +        status = myself(session, tmp_msg->from);
   4.237 +        if (status != PEP_STATUS_OK)
   4.238 +            GOTO(pep_error);
   4.239 +    }
   4.240 +
   4.241 +    // Own identities can be retrieved here where they would otherwise
   4.242 +    // fail because we lack all other information. This is ok and even
   4.243 +    // desired. FIXME: IS it?
   4.244 +    status = update_identity_recip_list(session, tmp_msg->to);
   4.245 +    if (status != PEP_STATUS_OK)
   4.246 +        GOTO(pep_error);
   4.247 +
   4.248 +    status = update_identity_recip_list(session, tmp_msg->cc);
   4.249 +    if (status != PEP_STATUS_OK)
   4.250 +        GOTO(pep_error);
   4.251 +
   4.252 +    status = update_identity_recip_list(session, tmp_msg->bcc);
   4.253 +    if (status != PEP_STATUS_OK)
   4.254 +        GOTO(pep_error);
   4.255 +    
   4.256      // This isn't incoming, though... so we need to reverse the direction
   4.257      tmp_msg->dir = PEP_dir_outgoing;
   4.258      status = encrypt_message(session,
     5.1 --- a/src/pEpEngine.c	Wed Jan 17 11:16:22 2018 +0100
     5.2 +++ b/src/pEpEngine.c	Thu Jan 18 00:46:19 2018 +0100
     5.3 @@ -47,10 +47,10 @@
     5.4      "select id, word from wordlist where lang = lower(?1) "
     5.5      "and id = ?2 ;";
     5.6  
     5.7 -
     5.8  static const char *sql_get_identity =  
     5.9      "select fpr, username, comm_type, lang,"
    5.10 -    "   identity.flags | pgp_keypair.flags"
    5.11 +    "   identity.flags | pgp_keypair.flags,"
    5.12 +    "   is_own"
    5.13      "   from identity"
    5.14      "   join person on id = identity.user_id"
    5.15      "   join pgp_keypair on fpr = identity.main_key_id"
    5.16 @@ -63,10 +63,37 @@
    5.17      "          end) = 1"
    5.18      "   and identity.user_id = ?2;";
    5.19  
    5.20 +static const char *sql_get_identity_without_trust_check =  
    5.21 +    "select identity.main_key_id, username, lang,"
    5.22 +    "   identity.flags, is_own"
    5.23 +    "   from identity"
    5.24 +    "   join person on id = identity.user_id"
    5.25 +    "   where (case when (address = ?1) then (1)"
    5.26 +    "               when (lower(address) = lower(?1)) then (1)"
    5.27 +    "               when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1)"
    5.28 +    "               else 0"
    5.29 +    "          end) = 1"
    5.30 +    "   and identity.user_id = ?2;";
    5.31 +
    5.32 +static const char *sql_get_identities_by_address =  
    5.33 +    "select user_id, identity.main_key_id, username, lang,"
    5.34 +    "   identity.flags, is_own"
    5.35 +    "   from identity"
    5.36 +    "   join person on id = identity.user_id"
    5.37 +    "   where (case when (address = ?1) then (1)"
    5.38 +    "               when (lower(address) = lower(?1)) then (1)"
    5.39 +    "               when (replace(lower(address),'.','') = replace(lower(?1),'.','')) then (1)"
    5.40 +    "               else 0"
    5.41 +    "          end) = 1;";
    5.42 +
    5.43  static const char *sql_replace_identities_fpr =  
    5.44      "update identity"
    5.45      "   set main_key_id = ?1 "
    5.46      "   where main_key_id = ?2 ;";
    5.47 +    
    5.48 +static const char *sql_remove_fpr_as_default =
    5.49 +    "update person set main_key_id = NULL where main_key_id = ?1 ;"
    5.50 +    "update identity set main_key_id = NULL where main_key_id = ?1 ;";
    5.51  
    5.52  // Set person, but if already exist, only update.
    5.53  // if main_key_id already set, don't touch.
    5.54 @@ -79,11 +106,16 @@
    5.55  
    5.56  static const char *sql_set_device_group = 
    5.57      "update person set device_group = ?1 "
    5.58 -    "where id = '" PEP_OWN_USERID "';";
    5.59 +    "where id = ?2;";
    5.60 +
    5.61 +// This will cascade to identity and trust
    5.62 +static const char* sql_replace_userid =
    5.63 +    "update person set id = ?1 " 
    5.64 +    "where id = ?2;";
    5.65  
    5.66  static const char *sql_get_device_group = 
    5.67      "select device_group from person "
    5.68 -    "where id = '" PEP_OWN_USERID "';";
    5.69 +    "where id = ?1;";
    5.70  
    5.71  static const char *sql_set_pgp_keypair = 
    5.72      "insert or replace into pgp_keypair (fpr) "
    5.73 @@ -92,7 +124,7 @@
    5.74  static const char *sql_set_identity = 
    5.75      "insert or replace into identity ("
    5.76      " address, main_key_id, "
    5.77 -    " user_id, flags"
    5.78 +    " user_id, flags, is_own"
    5.79      ") values ("
    5.80      " ?1,"
    5.81      " upper(replace(?2,' ','')),"
    5.82 @@ -105,7 +137,8 @@
    5.83      // "    0)"
    5.84      // " ) | (?4 & 255)"
    5.85      /* set_identity ignores previous flags, and doesn't filter machine flags */
    5.86 -    " ?4"
    5.87 +    " ?4,"
    5.88 +    " ?5"
    5.89      ");";
    5.90          
    5.91  static const char *sql_set_identity_flags = 
    5.92 @@ -154,7 +187,6 @@
    5.93  static const char *sql_i18n_token = 
    5.94      "select phrase from i18n_token where lang = lower(?1) and id = ?2 ;";
    5.95  
    5.96 -
    5.97  // blacklist
    5.98  static const char *sql_blacklist_add = 
    5.99      "insert or replace into blacklist_keys (fpr) values (upper(replace(?1,' ',''))) ;"
   5.100 @@ -172,40 +204,39 @@
   5.101                  
   5.102  
   5.103  // Own keys
   5.104 +// We only care if it's 0 or non-zero
   5.105  static const char *sql_own_key_is_listed = 
   5.106      "select count(*) from ("
   5.107 -    " select main_key_id from person "
   5.108 -    "   where main_key_id = upper(replace(?1,' ',''))"
   5.109 -    "    and id = '" PEP_OWN_USERID "' "
   5.110 -    " union "
   5.111 -    "  select main_key_id from identity "
   5.112 -    "   where main_key_id = upper(replace(?1,' ',''))"
   5.113 -    "    and user_id = '" PEP_OWN_USERID "' "
   5.114 -    " union "
   5.115 -    "  select fpr from own_keys "
   5.116 -    "   where fpr = upper(replace(?1,' ',''))"
   5.117 -    " );";
   5.118 +    "   select pgp_keypair_fpr from trust"
   5.119 +    "      join identity on trust.user_id = identity.user_id"
   5.120 +    "      where pgp_keypair_fpr = upper(replace(?1,' ',''))"
   5.121 +    "           and identity.is_own = 1"
   5.122 +    ");";
   5.123  
   5.124  static const char *sql_own_identities_retrieve =  
   5.125 -    "select address, fpr, username, "
   5.126 +    "select address, fpr, username, identity.user_id, "
   5.127      "   lang, identity.flags | pgp_keypair.flags"
   5.128      "   from identity"
   5.129      "   join person on id = identity.user_id"
   5.130      "   join pgp_keypair on fpr = identity.main_key_id"
   5.131      "   join trust on id = trust.user_id"
   5.132      "       and pgp_keypair_fpr = identity.main_key_id"
   5.133 -    "   where identity.user_id = '" PEP_OWN_USERID "'"
   5.134 +    "   where identity.is_own = 1"
   5.135      "       and (identity.flags & ?1) = 0;";
   5.136 -        
   5.137 -static const char *sql_own_keys_retrieve =  
   5.138 -    "select fpr from own_keys"
   5.139 -    "   natural join identity"
   5.140 -    "   where (identity.flags & ?1) = 0;";
   5.141 -
   5.142 -static const char *sql_set_own_key = 
   5.143 -    "insert or replace into own_keys (address, user_id, fpr)"
   5.144 -    " values (?1, '" PEP_OWN_USERID "', upper(replace(?2,' ','')));";
   5.145 -
   5.146 +
   5.147 +static const char *sql_own_keys_retrieve = 
   5.148 +    "select pgp_keypair_fpr from trust"
   5.149 +    "   join identity on trust.user_id = identity.user_id"
   5.150 +    "   where identity.is_own = 1";
   5.151 +
   5.152 +static const char* sql_get_user_default_key =
   5.153 +    "select main_key_id from person" 
   5.154 +    "   where id = ?1;";
   5.155 +
   5.156 +static const char* sql_get_default_own_userid =
   5.157 +    "select id from person"
   5.158 +    "   join identity on id = identity.user_id"
   5.159 +    "   where identity.is_own = 1";
   5.160  
   5.161  // Sequence
   5.162  static const char *sql_sequence_value1 = 
   5.163 @@ -238,6 +269,14 @@
   5.164      "select revoked_fpr, revocation_date from revoked_keys"
   5.165      "    where replacement_fpr = upper(replace(?1,' ','')) ;";
   5.166  
   5.167 +static const char *sql_get_userid_alias_default =
   5.168 +    "select default_id from alternate_user_id "
   5.169 +    "   where alternate_id = ?1 ; ";
   5.170 +
   5.171 +static const char *sql_add_userid_alias =
   5.172 +    "insert or replace into alternate_user_id (default_id, alternate_id) "
   5.173 +    "values (?1, ?2) ;";
   5.174 +    
   5.175  static int user_version(void *_version, int count, char **text, char **name)
   5.176  {
   5.177      assert(_version);
   5.178 @@ -251,6 +290,56 @@
   5.179      return 0;
   5.180  }
   5.181  
   5.182 +static int table_contains_column(PEP_SESSION session, const char* table_name,
   5.183 +                                                      const char* col_name) {
   5.184 +
   5.185 +
   5.186 +    if (!session || !table_name || !col_name)
   5.187 +        return -1;
   5.188 +        
   5.189 +    // Table names can't be SQL parameters, so we do it this way.
   5.190 +    
   5.191 +    // these two must be the same number.
   5.192 +    char sql_buf[500];
   5.193 +    const size_t max_q_len = 500;
   5.194 +    
   5.195 +    size_t t_size, c_size, q_size;
   5.196 +    
   5.197 +    const char* q1 = "SELECT "; // 7
   5.198 +    const char* q2 = " from "; // 6
   5.199 +    const char* q3 = ";";       // 1
   5.200 +    
   5.201 +    q_size = 14;
   5.202 +    t_size = strlen(table_name);
   5.203 +    c_size = strlen(col_name);
   5.204 +    
   5.205 +    size_t query_len = q_size + c_size + t_size + 1;
   5.206 +    
   5.207 +    if (query_len > max_q_len)
   5.208 +        return -1;
   5.209 +
   5.210 +    strlcpy(sql_buf, q1, max_q_len);
   5.211 +    strlcat(sql_buf, col_name, max_q_len);
   5.212 +    strlcat(sql_buf, q2, max_q_len);
   5.213 +    strlcat(sql_buf, table_name, max_q_len);
   5.214 +    strlcat(sql_buf, q3, max_q_len);
   5.215 +
   5.216 +    sqlite3_stmt *stmt; 
   5.217 +
   5.218 +    sqlite3_prepare_v2(session->db, sql_buf, -1, &stmt, NULL);
   5.219 +
   5.220 +    int retval = 0;
   5.221 +
   5.222 +    int rc = sqlite3_step(stmt);  
   5.223 +    if (rc == SQLITE_DONE || rc == SQLITE_OK || rc == SQLITE_ROW) {
   5.224 +        retval = 1;
   5.225 +    }
   5.226 +
   5.227 +    sqlite3_finalize(stmt);      
   5.228 +        
   5.229 +    return retval;
   5.230 +}
   5.231 +
   5.232  DYNAMIC_API PEP_STATUS init(PEP_SESSION *session)
   5.233  {
   5.234      PEP_STATUS status = PEP_STATUS_OK;
   5.235 @@ -358,7 +447,7 @@
   5.236      sqlite3_busy_timeout(_session->system_db, 1000);
   5.237  
   5.238  // increment this when patching DDL
   5.239 -#define _DDL_USER_VERSION "5"
   5.240 +#define _DDL_USER_VERSION "6"
   5.241  
   5.242      if (in_first) {
   5.243  
   5.244 @@ -411,18 +500,19 @@
   5.245                  "   address text,\n"
   5.246                  "   user_id text\n"
   5.247                  "       references person (id)\n"
   5.248 -                "       on delete cascade,\n"
   5.249 +                "       on delete cascade on update cascade,\n"
   5.250                  "   main_key_id text\n"
   5.251                  "       references pgp_keypair (fpr)\n"
   5.252                  "       on delete set null,\n"
   5.253                  "   comment text,\n"
   5.254 -                "   flags integer default 0,"
   5.255 +                "   flags integer default 0,\n"
   5.256 +                "   is_own integer default 0,\n"
   5.257                  "   primary key (address, user_id)\n"
   5.258                  ");\n"
   5.259                  "create table if not exists trust (\n"
   5.260                  "   user_id text not null\n"
   5.261                  "       references person (id)\n"
   5.262 -                "       on delete cascade,\n"
   5.263 +                "       on delete cascade on update cascade,\n"
   5.264                  "   pgp_keypair_fpr text not null\n"
   5.265                  "       references pgp_keypair (fpr)\n"
   5.266                  "       on delete cascade,\n"
   5.267 @@ -447,18 +537,12 @@
   5.268                  "       on delete cascade,\n"
   5.269                  "   revocation_date integer\n"
   5.270                  ");\n"
   5.271 -                "create table if not exists own_keys (\n"
   5.272 -                "   address text,\n"
   5.273 -                "   user_id text,\n"
   5.274 -                "   fpr text not null\n"
   5.275 -                "       references pgp_keypair (fpr)\n"
   5.276 -                "       on delete cascade,\n"
   5.277 -                "   foreign key (address, user_id)\n"
   5.278 -                "       references identity\n"
   5.279 -                "       on delete cascade,\n"
   5.280 -                "   check (user_id = '" PEP_OWN_USERID "')\n"
   5.281 -                "   primary key (address, fpr)\n"
   5.282 -                ");\n" 
   5.283 +                // user id aliases
   5.284 +                "create table if not exists alternate_user_id (\n"
   5.285 +                "    default_id text references person (id)\n"
   5.286 +                "       on delete cascade on update cascade,\n"
   5.287 +                "    alternate_id text primary key\n"
   5.288 +                ");\n"
   5.289                  ,
   5.290              NULL,
   5.291              NULL,
   5.292 @@ -490,6 +574,48 @@
   5.293              NULL,
   5.294              NULL);
   5.295          assert(int_result == SQLITE_OK);
   5.296 +        
   5.297 +        // Sometimes the user_version wasn't set correctly. Check to see if this
   5.298 +        // is really necessary...
   5.299 +        if (version == 1) {
   5.300 +            bool version_changed = true;
   5.301 +            
   5.302 +            if (table_contains_column(_session, "identity", "is_own") > 0) {
   5.303 +                version = 6;
   5.304 +            }
   5.305 +            else if (table_contains_column(_session, "sequences", "own") > 0) {
   5.306 +                version = 3;
   5.307 +            }
   5.308 +            else if (table_contains_column(_session, "pgp_keypair", "flags") > 0) {
   5.309 +                version = 2;
   5.310 +            }
   5.311 +            else {
   5.312 +                version_changed = false;
   5.313 +            }
   5.314 +            
   5.315 +            if (version_changed) {
   5.316 +                // set it in the DB, finally. Yeesh.
   5.317 +                char verbuf[21]; // enough digits for a max-sized 64 bit int, cmon. 
   5.318 +                sprintf(verbuf,"%d",version);
   5.319 +                
   5.320 +                size_t query_size = strlen(verbuf) + 25;
   5.321 +                char* query = calloc(query_size, 1);
   5.322 +                
   5.323 +                strlcpy(query, "pragma user_version = ", query_size);
   5.324 +                strlcat(query, verbuf, query_size);
   5.325 +                strlcat(query, ";", query_size);
   5.326 +                
   5.327 +                int_result = sqlite3_exec(
   5.328 +                    _session->db,
   5.329 +                    query,
   5.330 +                    user_version,
   5.331 +                    &version,
   5.332 +                    NULL
   5.333 +                );
   5.334 +                free(query);
   5.335 +            }
   5.336 +        }
   5.337 +
   5.338  
   5.339          if(version != 0) { 
   5.340              // Version has been already set
   5.341 @@ -510,7 +636,7 @@
   5.342              //     );
   5.343              //     assert(int_result == SQLITE_OK);
   5.344              // }
   5.345 -
   5.346 +            
   5.347              if (version < 2) {
   5.348                  int_result = sqlite3_exec(
   5.349                      _session->db,
   5.350 @@ -555,6 +681,81 @@
   5.351                  );
   5.352                  assert(int_result == SQLITE_OK);
   5.353              }
   5.354 +            
   5.355 +            if (version < 6) {
   5.356 +                int_result = sqlite3_exec(
   5.357 +                    _session->db,
   5.358 +                    "alter table identity\n"
   5.359 +                    "   add column is_own integer default 0;\n",
   5.360 +                    NULL,
   5.361 +                    NULL,
   5.362 +                    NULL
   5.363 +                );
   5.364 +                assert(int_result == SQLITE_OK);                
   5.365 +                int_result = sqlite3_exec(
   5.366 +                    _session->db,
   5.367 +                    "update identity\n"
   5.368 +                    "   set is_own = 1\n"
   5.369 +                    "   where (user_id = '" PEP_OWN_USERID "');\n",
   5.370 +                    NULL,
   5.371 +                    NULL,
   5.372 +                    NULL
   5.373 +                );
   5.374 +                assert(int_result == SQLITE_OK);    
   5.375 +
   5.376 +                // Turns out that just adding "on update cascade" in
   5.377 +                // sqlite is a PITA. We need to be able to cascade
   5.378 +                // person->id replacements (for temp ids like "TOFU_")
   5.379 +                // so here we go...
   5.380 +                int_result = sqlite3_exec(
   5.381 +                    _session->db,
   5.382 +                    "PRAGMA foreign_keys=off;\n"
   5.383 +                    "BEGIN TRANSACTION;\n"
   5.384 +                    "ALTER TABLE identity RENAME TO _identity_old;\n"
   5.385 +                    "create table identity (\n"
   5.386 +                    "   address text,\n"
   5.387 +                    "   user_id text\n"
   5.388 +                    "       references person (id)\n"
   5.389 +                    "       on delete cascade on update cascade,\n"
   5.390 +                    "   main_key_id text\n"
   5.391 +                    "       references pgp_keypair (fpr)\n"
   5.392 +                    "       on delete set null,\n"
   5.393 +                    "   comment text,\n"
   5.394 +                    "   flags integer default 0,\n"
   5.395 +                    "   is_own integer default 0,\n"
   5.396 +                    "   primary key (address, user_id)\n"
   5.397 +                    ");\n"
   5.398 +                    "INSERT INTO identity SELECT * FROM _identity_old;\n"
   5.399 +                    "DROP TABLE _identity_old;\n"
   5.400 +                    "ALTER TABLE trust RENAME TO _trust_old;\n"
   5.401 +                    "create table trust (\n"
   5.402 +                    "   user_id text not null\n"
   5.403 +                    "       references person (id)\n"
   5.404 +                    "       on delete cascade on update cascade,\n"
   5.405 +                    "   pgp_keypair_fpr text not null\n"
   5.406 +                    "       references pgp_keypair (fpr)\n"
   5.407 +                    "       on delete cascade,\n"
   5.408 +                    "   comm_type integer not null,\n"
   5.409 +                    "   comment text,\n"
   5.410 +                    "   primary key (user_id, pgp_keypair_fpr)\n"
   5.411 +                    ");\n"
   5.412 +                    "INSERT INTO trust SELECT * FROM _trust_old;\n"
   5.413 +                    "DROP TABLE _trust_old;\n"
   5.414 +                    "COMMIT;\n"
   5.415 +                    "\n"
   5.416 +                    "PRAGMA foreign_keys=on;\n"
   5.417 +                    "create table if not exists alternate_user_id (\n"
   5.418 +                    "    default_id text references person (id)\n"
   5.419 +                    "       on delete cascade on update cascade,\n"
   5.420 +                    "    alternate_id text primary key\n"
   5.421 +                    ");\n"
   5.422 +                    ,
   5.423 +                    NULL,
   5.424 +                    NULL,
   5.425 +                    NULL
   5.426 +                );
   5.427 +                assert(int_result == SQLITE_OK);    
   5.428 +            }
   5.429          }
   5.430          else { 
   5.431              // Version from DB was 0, it means this is initial setup.
   5.432 @@ -592,10 +793,45 @@
   5.433              (int)strlen(sql_get_identity), &_session->get_identity, NULL);
   5.434      assert(int_result == SQLITE_OK);
   5.435  
   5.436 +    int_result = sqlite3_prepare_v2(_session->db, sql_get_identity_without_trust_check,
   5.437 +            (int)strlen(sql_get_identity_without_trust_check), 
   5.438 +            &_session->get_identity_without_trust_check, NULL);
   5.439 +    assert(int_result == SQLITE_OK);
   5.440 +
   5.441 +    int_result = sqlite3_prepare_v2(_session->db, sql_get_identities_by_address,
   5.442 +            (int)strlen(sql_get_identities_by_address), 
   5.443 +            &_session->get_identities_by_address, NULL);
   5.444 +    assert(int_result == SQLITE_OK);
   5.445 +
   5.446 +    int_result = sqlite3_prepare_v2(_session->db, sql_get_user_default_key,
   5.447 +            (int)strlen(sql_get_user_default_key), &_session->get_user_default_key, NULL);
   5.448 +    assert(int_result == SQLITE_OK);
   5.449 +
   5.450 +    int_result = sqlite3_prepare_v2(_session->db, sql_get_default_own_userid,
   5.451 +            (int)strlen(sql_get_default_own_userid), &_session->get_default_own_userid, NULL);
   5.452 +    assert(int_result == SQLITE_OK);
   5.453 +    
   5.454 +    int_result = sqlite3_prepare_v2(_session->db, sql_get_userid_alias_default,
   5.455 +            (int)strlen(sql_get_userid_alias_default), &_session->get_userid_alias_default, NULL);
   5.456 +    assert(int_result == SQLITE_OK);
   5.457 +
   5.458 +    int_result = sqlite3_prepare_v2(_session->db, sql_add_userid_alias,
   5.459 +            (int)strlen(sql_add_userid_alias), &_session->add_userid_alias, NULL);
   5.460 +    assert(int_result == SQLITE_OK);
   5.461 +
   5.462 +    int_result = sqlite3_prepare_v2(_session->db, sql_replace_userid,
   5.463 +            (int)strlen(sql_replace_userid), &_session->replace_userid, NULL);
   5.464 +    assert(int_result == SQLITE_OK);
   5.465 +
   5.466      int_result = sqlite3_prepare_v2(_session->db, sql_replace_identities_fpr,
   5.467              (int)strlen(sql_replace_identities_fpr), 
   5.468              &_session->replace_identities_fpr, NULL);
   5.469      assert(int_result == SQLITE_OK);
   5.470 +    
   5.471 +    int_result = sqlite3_prepare_v2(_session->db, sql_remove_fpr_as_default,
   5.472 +            (int)strlen(sql_remove_fpr_as_default), 
   5.473 +            &_session->remove_fpr_as_default, NULL);
   5.474 +    assert(int_result == SQLITE_OK);
   5.475  
   5.476      int_result = sqlite3_prepare_v2(_session->db, sql_set_person,
   5.477              (int)strlen(sql_set_person), &_session->set_person, NULL);
   5.478 @@ -660,7 +896,7 @@
   5.479      int_result = sqlite3_prepare_v2(_session->system_db, sql_i18n_token,
   5.480              (int)strlen(sql_i18n_token), &_session->i18n_token, NULL);
   5.481      assert(int_result == SQLITE_OK);
   5.482 -
   5.483 +    
   5.484      // blacklist
   5.485  
   5.486      int_result = sqlite3_prepare_v2(_session->db, sql_blacklist_add,
   5.487 @@ -699,10 +935,10 @@
   5.488              &_session->own_keys_retrieve, NULL);
   5.489      assert(int_result == SQLITE_OK);
   5.490   
   5.491 -    int_result = sqlite3_prepare_v2(_session->db, sql_set_own_key,
   5.492 -            (int)strlen(sql_set_own_key),
   5.493 -            &_session->set_own_key, NULL);
   5.494 -    assert(int_result == SQLITE_OK);
   5.495 +    // int_result = sqlite3_prepare_v2(_session->db, sql_set_own_key,
   5.496 +    //         (int)strlen(sql_set_own_key),
   5.497 +    //         &_session->set_own_key, NULL);
   5.498 +    // assert(int_result == SQLITE_OK);
   5.499   
   5.500      // Sequence
   5.501  
   5.502 @@ -833,8 +1069,22 @@
   5.503                  sqlite3_finalize(session->trustword);
   5.504              if (session->get_identity)
   5.505                  sqlite3_finalize(session->get_identity);
   5.506 +            if (session->get_identity_without_trust_check)
   5.507 +                sqlite3_finalize(session->get_identity_without_trust_check);
   5.508 +            if (session->get_identities_by_address)
   5.509 +                sqlite3_finalize(session->get_identities_by_address);            
   5.510 +            if (session->get_user_default_key)
   5.511 +                sqlite3_finalize(session->get_user_default_key);    
   5.512 +            if (session->get_default_own_userid)
   5.513 +                sqlite3_finalize(session->get_default_own_userid);
   5.514 +            if (session->get_userid_alias_default)
   5.515 +                sqlite3_finalize(session->get_userid_alias_default);
   5.516 +            if (session->add_userid_alias)
   5.517 +                sqlite3_finalize(session->add_userid_alias);
   5.518              if (session->replace_identities_fpr)
   5.519                  sqlite3_finalize(session->replace_identities_fpr);        
   5.520 +            if (session->remove_fpr_as_default)
   5.521 +                sqlite3_finalize(session->remove_fpr_as_default);            
   5.522              if (session->set_person)
   5.523                  sqlite3_finalize(session->set_person);
   5.524              if (session->set_device_group)
   5.525 @@ -865,6 +1115,8 @@
   5.526                  sqlite3_finalize(session->languagelist);
   5.527              if (session->i18n_token)
   5.528                  sqlite3_finalize(session->i18n_token);
   5.529 +            if (session->replace_userid)
   5.530 +                sqlite3_finalize(session->replace_userid);
   5.531              if (session->blacklist_add)
   5.532                  sqlite3_finalize(session->blacklist_add);
   5.533              if (session->blacklist_delete)
   5.534 @@ -879,8 +1131,8 @@
   5.535                  sqlite3_finalize(session->own_identities_retrieve);
   5.536              if (session->own_keys_retrieve)
   5.537                  sqlite3_finalize(session->own_keys_retrieve);
   5.538 -            if (session->set_own_key)
   5.539 -                sqlite3_finalize(session->set_own_key);
   5.540 +            // if (session->set_own_key)
   5.541 +            //     sqlite3_finalize(session->set_own_key);
   5.542              if (session->sequence_value1)
   5.543                  sqlite3_finalize(session->sequence_value1);
   5.544              if (session->sequence_value2)
   5.545 @@ -1183,7 +1435,8 @@
   5.546      dup->lang[1] = src->lang[1];
   5.547      dup->lang[2] = 0;
   5.548      dup->flags = src->flags;
   5.549 -
   5.550 +    dup->me = src->me;
   5.551 +    
   5.552      return dup;
   5.553  }
   5.554  
   5.555 @@ -1198,6 +1451,124 @@
   5.556      }
   5.557  }
   5.558  
   5.559 +DYNAMIC_API PEP_STATUS get_default_own_userid(
   5.560 +        PEP_SESSION session, 
   5.561 +        char** userid
   5.562 +    )
   5.563 +{
   5.564 +    assert(session);
   5.565 +    assert(userid);
   5.566 +    
   5.567 +    if (!session || !userid)
   5.568 +        return PEP_ILLEGAL_VALUE;
   5.569 +        
   5.570 +    PEP_STATUS status = PEP_STATUS_OK;
   5.571 +    char* retval = NULL;
   5.572 +    
   5.573 +    sqlite3_reset(session->get_default_own_userid);
   5.574 +
   5.575 +    const int result = sqlite3_step(session->get_default_own_userid);
   5.576 +    const char* id;
   5.577 +    
   5.578 +    switch (result) {
   5.579 +        case SQLITE_ROW:
   5.580 +            id = (const char *) sqlite3_column_text(session->get_default_own_userid, 0);
   5.581 +            if (!id) {
   5.582 +                // Shouldn't happen.
   5.583 +                status = PEP_UNKNOWN_ERROR;
   5.584 +            }
   5.585 +            else {
   5.586 +                retval = strdup(id);
   5.587 +                if (!retval)
   5.588 +                    status = PEP_OUT_OF_MEMORY;
   5.589 +            }
   5.590 +            break;
   5.591 +        default:
   5.592 +            // Technically true, given how we find it, but FIXME we need a more descriptive error
   5.593 +            status = PEP_CANNOT_FIND_IDENTITY;
   5.594 +            *userid = NULL;
   5.595 +    }
   5.596 +
   5.597 +    *userid = retval;
   5.598 +
   5.599 +    sqlite3_reset(session->get_default_own_userid);
   5.600 +    
   5.601 +    return status;
   5.602 +}
   5.603 +
   5.604 +DYNAMIC_API PEP_STATUS get_userid_alias_default(
   5.605 +        PEP_SESSION session, 
   5.606 +        const char* alias_id,
   5.607 +        char** default_id) {
   5.608 +            
   5.609 +    assert(session);
   5.610 +    assert(alias_id);
   5.611 +    assert(alias_id[0]);
   5.612 +    assert(default_id);
   5.613 +
   5.614 +    if (!(session && alias_id && alias_id[0] && default_id))
   5.615 +        return PEP_ILLEGAL_VALUE;
   5.616 +
   5.617 +    PEP_STATUS status = PEP_STATUS_OK;
   5.618 +    char* retval = NULL;
   5.619 +
   5.620 +    sqlite3_reset(session->get_userid_alias_default);
   5.621 +    sqlite3_bind_text(session->get_userid_alias_default, 1, alias_id, -1, SQLITE_STATIC);
   5.622 +
   5.623 +    const char* tempid;
   5.624 +    
   5.625 +    const int result = sqlite3_step(session->get_userid_alias_default);
   5.626 +    switch (result) {
   5.627 +    case SQLITE_ROW:
   5.628 +        tempid = (const char *) sqlite3_column_text(session->get_userid_alias_default, 0);
   5.629 +        if (tempid) {
   5.630 +            retval = strdup(tempid);
   5.631 +            assert(retval);
   5.632 +            if (retval == NULL)
   5.633 +                return PEP_OUT_OF_MEMORY;
   5.634 +        }
   5.635 +    
   5.636 +        *default_id = retval;
   5.637 +        break;
   5.638 +    default:
   5.639 +        status = PEP_CANNOT_FIND_ALIAS;
   5.640 +        *default_id = NULL;
   5.641 +    }
   5.642 +
   5.643 +    sqlite3_reset(session->get_userid_alias_default);
   5.644 +    return status;            
   5.645 +}
   5.646 +
   5.647 +DYNAMIC_API PEP_STATUS set_userid_alias (
   5.648 +        PEP_SESSION session, 
   5.649 +        const char* default_id,
   5.650 +        const char* alias_id) {
   5.651 +            
   5.652 +    int result;
   5.653 +
   5.654 +    assert(session);
   5.655 +    assert(default_id);
   5.656 +    assert(alias_id);
   5.657 +
   5.658 +    if (!(session && default_id && alias_id && 
   5.659 +          default_id[0] != '\0' && alias_id[0] != '\0'))
   5.660 +        return PEP_ILLEGAL_VALUE;
   5.661 +
   5.662 +    sqlite3_reset(session->add_userid_alias);
   5.663 +    sqlite3_bind_text(session->add_userid_alias, 1, default_id, -1,
   5.664 +            SQLITE_STATIC);
   5.665 +    sqlite3_bind_text(session->add_userid_alias, 2, alias_id, -1,
   5.666 +            SQLITE_STATIC);
   5.667 +        
   5.668 +    result = sqlite3_step(session->add_userid_alias);
   5.669 +
   5.670 +    sqlite3_reset(session->add_userid_alias);
   5.671 +    if (result != SQLITE_DONE)
   5.672 +        return PEP_CANNOT_SET_ALIAS;
   5.673 +    
   5.674 +    return PEP_STATUS_OK;
   5.675 +}
   5.676 +
   5.677  DYNAMIC_API PEP_STATUS get_identity(
   5.678          PEP_SESSION session,
   5.679          const char *address,
   5.680 @@ -1249,6 +1620,9 @@
   5.681          }
   5.682          _identity->flags = (unsigned int)
   5.683              sqlite3_column_int(session->get_identity, 4);
   5.684 +        _identity->me = (unsigned int)
   5.685 +            sqlite3_column_int(session->get_identity, 5);
   5.686 +    
   5.687          *identity = _identity;
   5.688          break;
   5.689      default:
   5.690 @@ -1260,6 +1634,140 @@
   5.691      return status;
   5.692  }
   5.693  
   5.694 +PEP_STATUS get_identity_without_trust_check(
   5.695 +        PEP_SESSION session,
   5.696 +        const char *address,
   5.697 +        const char *user_id,
   5.698 +        pEp_identity **identity
   5.699 +    )
   5.700 +{
   5.701 +    PEP_STATUS status = PEP_STATUS_OK;
   5.702 +    static pEp_identity *_identity;
   5.703 +
   5.704 +    assert(session);
   5.705 +    assert(address);
   5.706 +    assert(address[0]);
   5.707 +    assert(identity);
   5.708 +
   5.709 +    if (!(session && address && address[0] && identity))
   5.710 +        return PEP_ILLEGAL_VALUE;
   5.711 +
   5.712 +    *identity = NULL;
   5.713 +
   5.714 +    sqlite3_reset(session->get_identity_without_trust_check);
   5.715 +    sqlite3_bind_text(session->get_identity_without_trust_check, 1, address, -1, SQLITE_STATIC);
   5.716 +    sqlite3_bind_text(session->get_identity_without_trust_check, 2, user_id, -1, SQLITE_STATIC);
   5.717 +
   5.718 +    const int result = sqlite3_step(session->get_identity_without_trust_check);
   5.719 +    switch (result) {
   5.720 +    case SQLITE_ROW:
   5.721 +        _identity = new_identity(
   5.722 +                address,
   5.723 +                (const char *) sqlite3_column_text(session->get_identity_without_trust_check, 0),
   5.724 +                user_id,
   5.725 +                (const char *) sqlite3_column_text(session->get_identity_without_trust_check, 1)
   5.726 +                );
   5.727 +        assert(_identity);
   5.728 +        if (_identity == NULL)
   5.729 +            return PEP_OUT_OF_MEMORY;
   5.730 +
   5.731 +        _identity->comm_type = PEP_ct_unknown;
   5.732 +        const char* const _lang = (const char *)
   5.733 +            sqlite3_column_text(session->get_identity_without_trust_check, 2);
   5.734 +        if (_lang && _lang[0]) {
   5.735 +            assert(_lang[0] >= 'a' && _lang[0] <= 'z');
   5.736 +            assert(_lang[1] >= 'a' && _lang[1] <= 'z');
   5.737 +            assert(_lang[2] == 0);
   5.738 +            _identity->lang[0] = _lang[0];
   5.739 +            _identity->lang[1] = _lang[1];
   5.740 +            _identity->lang[2] = 0;
   5.741 +        }
   5.742 +        _identity->flags = (unsigned int)
   5.743 +            sqlite3_column_int(session->get_identity_without_trust_check, 3);
   5.744 +        _identity->me = (unsigned int)
   5.745 +            sqlite3_column_int(session->get_identity_without_trust_check, 4);
   5.746 +    
   5.747 +        *identity = _identity;
   5.748 +        break;
   5.749 +    default:
   5.750 +        status = PEP_CANNOT_FIND_IDENTITY;
   5.751 +        *identity = NULL;
   5.752 +    }
   5.753 +
   5.754 +    sqlite3_reset(session->get_identity_without_trust_check);
   5.755 +    return status;
   5.756 +}
   5.757 +
   5.758 +PEP_STATUS get_identities_by_address(
   5.759 +        PEP_SESSION session,
   5.760 +        const char *address,
   5.761 +        identity_list** id_list
   5.762 +    )
   5.763 +{
   5.764 +    pEp_identity* ident;
   5.765 +
   5.766 +    assert(session);
   5.767 +    assert(address);
   5.768 +    assert(address[0]);
   5.769 +    assert(id_list);
   5.770 +
   5.771 +    if (!(session && address && address[0] && id_list))
   5.772 +        return PEP_ILLEGAL_VALUE;
   5.773 +
   5.774 +    *id_list = NULL;
   5.775 +    identity_list* ident_list = NULL;
   5.776 +
   5.777 +    sqlite3_reset(session->get_identities_by_address);
   5.778 +    sqlite3_bind_text(session->get_identities_by_address, 1, address, -1, SQLITE_STATIC);
   5.779 +    int result;
   5.780 +
   5.781 +    while ((result = sqlite3_step(session->get_identities_by_address)) == SQLITE_ROW) {
   5.782 +        //"select user_id, main_key_id, username, comm_type, lang,"
   5.783 +        //"   identity.flags, is_own"
   5.784 +        ident = new_identity(
   5.785 +                address,
   5.786 +                (const char *) sqlite3_column_text(session->get_identities_by_address, 1),
   5.787 +                (const char *) sqlite3_column_text(session->get_identities_by_address, 0),
   5.788 +                (const char *) sqlite3_column_text(session->get_identities_by_address, 2)
   5.789 +                );
   5.790 +        assert(ident);
   5.791 +        if (ident == NULL)
   5.792 +            return PEP_OUT_OF_MEMORY;
   5.793 +
   5.794 +        ident->comm_type = PEP_ct_unknown;
   5.795 +        
   5.796 +        const char* const _lang = (const char *)
   5.797 +            sqlite3_column_text(session->get_identities_by_address, 3);
   5.798 +        if (_lang && _lang[0]) {
   5.799 +            assert(_lang[0] >= 'a' && _lang[0] <= 'z');
   5.800 +            assert(_lang[1] >= 'a' && _lang[1] <= 'z');
   5.801 +            assert(_lang[2] == 0);
   5.802 +            ident->lang[0] = _lang[0];
   5.803 +            ident->lang[1] = _lang[1];
   5.804 +            ident->lang[2] = 0;
   5.805 +        }
   5.806 +        ident->flags = (unsigned int)
   5.807 +            sqlite3_column_int(session->get_identities_by_address, 4);
   5.808 +        ident->me = (unsigned int)
   5.809 +            sqlite3_column_int(session->get_identities_by_address, 5);
   5.810 +    
   5.811 +        if (ident_list)
   5.812 +            identity_list_add(ident_list, ident);
   5.813 +        else
   5.814 +            ident_list = new_identity_list(ident);
   5.815 +    }
   5.816 +
   5.817 +    sqlite3_reset(session->get_identities_by_address);
   5.818 +    
   5.819 +    *id_list = ident_list;
   5.820 +    
   5.821 +    if (!ident_list)
   5.822 +        return PEP_CANNOT_FIND_IDENTITY;
   5.823 +    
   5.824 +    return PEP_STATUS_OK;
   5.825 +}
   5.826 +
   5.827 +
   5.828  DYNAMIC_API PEP_STATUS set_identity(
   5.829          PEP_SESSION session, const pEp_identity *identity
   5.830      )
   5.831 @@ -1340,6 +1848,7 @@
   5.832      sqlite3_bind_text(session->set_identity, 3, identity->user_id, -1,
   5.833              SQLITE_STATIC);
   5.834      sqlite3_bind_int(session->set_identity, 4, identity->flags);
   5.835 +    sqlite3_bind_int(session->set_identity, 5, identity->me);
   5.836      result = sqlite3_step(session->set_identity);
   5.837      sqlite3_reset(session->set_identity);
   5.838      if (result != SQLITE_DONE) {
   5.839 @@ -1348,22 +1857,6 @@
   5.840      }
   5.841  
   5.842      if (has_fpr) {
   5.843 -        if(strcmp(identity->user_id, PEP_OWN_USERID) == 0) {
   5.844 -            sqlite3_reset(session->set_own_key);
   5.845 -            sqlite3_bind_text(session->set_own_key, 1, identity->address, -1,
   5.846 -                SQLITE_STATIC);
   5.847 -            sqlite3_bind_text(session->set_own_key, 2, identity->fpr, -1,
   5.848 -                SQLITE_STATIC);
   5.849 -            result = sqlite3_step(session->set_own_key);
   5.850 -            sqlite3_reset(session->set_own_key);
   5.851 -            if (result != SQLITE_DONE) {
   5.852 -                sqlite3_exec(session->db, "ROLLBACK ;", NULL, NULL, NULL);
   5.853 -                return PEP_CANNOT_SET_PGP_KEYPAIR;
   5.854 -            }
   5.855 -        }
   5.856 -
   5.857 -        // status = set_trust(session, identity->user_id, identity->fpr,
   5.858 -        //                    identity->comm_type)
   5.859          sqlite3_reset(session->set_trust);
   5.860          sqlite3_bind_text(session->set_trust, 1, identity->user_id, -1,
   5.861                  SQLITE_STATIC);
   5.862 @@ -1385,6 +1878,28 @@
   5.863          return PEP_COMMIT_FAILED;
   5.864  }
   5.865  
   5.866 +PEP_STATUS remove_fpr_as_default(PEP_SESSION session, 
   5.867 +                                 const char* fpr) 
   5.868 +{
   5.869 +    assert(fpr);
   5.870 +    
   5.871 +    if (!session || !fpr)
   5.872 +        return PEP_ILLEGAL_VALUE;
   5.873 +            
   5.874 +    sqlite3_reset(session->remove_fpr_as_default);
   5.875 +    sqlite3_bind_text(session->remove_fpr_as_default, 1, fpr, -1,
   5.876 +                      SQLITE_STATIC);
   5.877 +
   5.878 +    int result = sqlite3_step(session->remove_fpr_as_default);
   5.879 +    sqlite3_reset(session->remove_fpr_as_default);
   5.880 +    
   5.881 +    if (result != SQLITE_DONE)
   5.882 +        return PEP_CANNOT_SET_IDENTITY; // misleading - could also be person
   5.883 +
   5.884 +    return PEP_STATUS_OK;
   5.885 +}
   5.886 +
   5.887 +
   5.888  PEP_STATUS replace_identities_fpr(PEP_SESSION session, 
   5.889                                   const char* old_fpr, 
   5.890                                   const char* new_fpr) 
   5.891 @@ -1410,7 +1925,6 @@
   5.892      return PEP_STATUS_OK;
   5.893  }
   5.894  
   5.895 -
   5.896  PEP_STATUS update_trust_for_fpr(PEP_SESSION session, 
   5.897                                  const char* fpr, 
   5.898                                  PEP_comm_type comm_type)
   5.899 @@ -1443,6 +1957,15 @@
   5.900      if (!(session && group_name))
   5.901          return PEP_ILLEGAL_VALUE;
   5.902  
   5.903 +    // 1. Get own user_id
   5.904 +    char* user_id = NULL;
   5.905 +    PEP_STATUS status = get_default_own_userid(session, &user_id);
   5.906 +    
   5.907 +    // No user_id is returned in this case, no need to free;
   5.908 +    if (status != PEP_STATUS_OK)
   5.909 +        return status;
   5.910 +        
   5.911 +    // 2. Set device group
   5.912      sqlite3_reset(session->set_device_group);
   5.913      if(group_name){
   5.914          sqlite3_bind_text(session->set_device_group, 1, group_name, -1,
   5.915 @@ -1450,9 +1973,15 @@
   5.916      } else {
   5.917          sqlite3_bind_null(session->set_device_group, 1);
   5.918      }
   5.919 +    
   5.920 +    sqlite3_bind_text(session->set_device_group, 2, user_id, -1,
   5.921 +            SQLITE_STATIC);
   5.922  
   5.923      result = sqlite3_step(session->set_device_group);
   5.924      sqlite3_reset(session->set_device_group);
   5.925 +    
   5.926 +    free(user_id);
   5.927 +    
   5.928      if (result != SQLITE_DONE)
   5.929          return PEP_CANNOT_SET_PERSON;
   5.930  
   5.931 @@ -1470,7 +1999,18 @@
   5.932      if (!(session && group_name))
   5.933          return PEP_ILLEGAL_VALUE;
   5.934  
   5.935 +    // 1. Get own user_id
   5.936 +    char* user_id = NULL;
   5.937 +    status = get_default_own_userid(session, &user_id);
   5.938 +    
   5.939 +    // No user_id is returned in this case, no need to free;
   5.940 +    if (status != PEP_STATUS_OK)
   5.941 +        return status;
   5.942 +
   5.943 +    // 2. get device group
   5.944      sqlite3_reset(session->get_device_group);
   5.945 +    sqlite3_bind_text(session->get_device_group, 1, user_id, -1,
   5.946 +            SQLITE_STATIC);
   5.947  
   5.948      result = sqlite3_step(session->get_device_group);
   5.949      switch (result) {
   5.950 @@ -1488,6 +2028,7 @@
   5.951          status = PEP_RECORD_NOT_FOUND;
   5.952      }
   5.953  
   5.954 +    free(user_id);
   5.955      sqlite3_reset(session->get_device_group);
   5.956      return status;
   5.957  }
   5.958 @@ -1513,8 +2054,10 @@
   5.959      sqlite3_bind_text(session->set_identity_flags, 2, identity->address, -1,
   5.960              SQLITE_STATIC);
   5.961      sqlite3_bind_text(session->set_identity_flags, 3, identity->user_id, -1,
   5.962 -            SQLITE_STATIC);
   5.963 +        SQLITE_STATIC);
   5.964 +        
   5.965      result = sqlite3_step(session->set_identity_flags);
   5.966 +
   5.967      sqlite3_reset(session->set_identity_flags);
   5.968      if (result != SQLITE_DONE)
   5.969          return PEP_CANNOT_SET_IDENTITY;
   5.970 @@ -1554,6 +2097,32 @@
   5.971      return PEP_STATUS_OK;
   5.972  }
   5.973  
   5.974 +
   5.975 +PEP_STATUS replace_userid(PEP_SESSION session, const char* old_uid,
   5.976 +                              const char* new_uid) {
   5.977 +    assert(session);
   5.978 +    assert(old_uid);
   5.979 +    assert(new_uid);
   5.980 +    
   5.981 +    if (!session || !old_uid || !new_uid)
   5.982 +        return PEP_ILLEGAL_VALUE;
   5.983 +
   5.984 +
   5.985 +    int result;
   5.986 +
   5.987 +    sqlite3_reset(session->replace_userid);
   5.988 +    sqlite3_bind_text(session->replace_userid, 1, new_uid, -1,
   5.989 +            SQLITE_STATIC);
   5.990 +    sqlite3_bind_text(session->replace_userid, 2, old_uid, -1,
   5.991 +            SQLITE_STATIC);
   5.992 +    result = sqlite3_step(session->replace_userid);
   5.993 +    sqlite3_reset(session->replace_userid);
   5.994 +    if (result != SQLITE_DONE)
   5.995 +        return PEP_CANNOT_SET_PERSON; // May need clearer retval
   5.996 +
   5.997 +    return PEP_STATUS_OK;
   5.998 +}
   5.999 +
  5.1000  DYNAMIC_API PEP_STATUS mark_as_compromized(
  5.1001          PEP_SESSION session,
  5.1002          const char *fpr
  5.1003 @@ -1589,12 +2158,14 @@
  5.1004      PEP_STATUS status = PEP_STATUS_OK;
  5.1005      int result;
  5.1006  
  5.1007 -    assert(session);
  5.1008 -    assert(identity);
  5.1009 -    assert(identity->user_id);
  5.1010 -    assert(identity->user_id[0]);
  5.1011 -    assert(identity->fpr);
  5.1012 -    assert(identity->fpr[0]);
  5.1013 +    // We need to be able to test that we break correctly without shutting
  5.1014 +    // asserts off everywhere.
  5.1015 +    // assert(session);
  5.1016 +    // assert(identity);
  5.1017 +    // assert(identity->user_id);
  5.1018 +    // assert(identity->user_id[0]);
  5.1019 +    // assert(identity->fpr);
  5.1020 +    // assert(identity->fpr[0]);
  5.1021  
  5.1022      if (!(session && identity && identity->user_id && identity->user_id[0] &&
  5.1023                  identity->fpr && identity->fpr[0]))
     6.1 --- a/src/pEpEngine.h	Wed Jan 17 11:16:22 2018 +0100
     6.2 +++ b/src/pEpEngine.h	Thu Jan 18 00:46:19 2018 +0100
     6.3 @@ -47,6 +47,7 @@
     6.4      PEP_GET_KEY_FAILED                              = 0x0203,
     6.5      PEP_CANNOT_EXPORT_KEY                           = 0x0204,
     6.6      PEP_CANNOT_EDIT_KEY                             = 0x0205,
     6.7 +    PEP_KEY_UNSUITABLE                              = 0x0206,
     6.8      
     6.9      PEP_CANNOT_FIND_IDENTITY                        = 0x0301,
    6.10      PEP_CANNOT_SET_PERSON                           = 0x0381,
    6.11 @@ -55,6 +56,9 @@
    6.12      PEP_CANNOT_SET_TRUST                            = 0x0384,
    6.13      PEP_KEY_BLACKLISTED                             = 0x0385,
    6.14      
    6.15 +    PEP_CANNOT_FIND_ALIAS                           = 0x0391,
    6.16 +    PEP_CANNOT_SET_ALIAS                            = 0x0392,
    6.17 +    
    6.18      PEP_UNENCRYPTED                                 = 0x0400,
    6.19      PEP_VERIFIED                                    = 0x0401,
    6.20      PEP_DECRYPTED                                   = 0x0402,
    6.21 @@ -470,7 +474,6 @@
    6.22      // the first octet flags are app defined settings
    6.23      PEP_idf_not_for_sync = 0x0001,   // don't use this identity for sync
    6.24      PEP_idf_list = 0x0002,           // identity of list of persons
    6.25 -
    6.26      // the second octet flags are calculated
    6.27      PEP_idf_devicegroup = 0x0100     // identity of a device group member
    6.28  } identity_flags;
    6.29 @@ -486,13 +489,15 @@
    6.30      char *address;              // C string with address UTF-8 encoded
    6.31      char *fpr;                  // C string with fingerprint UTF-8 encoded
    6.32      char *user_id;              // C string with user ID UTF-8 encoded
    6.33 -                                // user_id must be set to "pEp_own_userId"
    6.34 +                                // user_id MIGHT be set to "pEp_own_userId"
    6.35                                  // (use PEP_OWN_USERID preprocessor define)
    6.36                                  // if this is own user's identity.
    6.37 +                                // But it is not REQUIRED to be.
    6.38      char *username;             // C string with user name UTF-8 encoded
    6.39      PEP_comm_type comm_type;    // type of communication with this ID
    6.40      char lang[3];               // language of conversation
    6.41                                  // ISO 639-1 ALPHA-2, last byte is 0
    6.42 +    bool me;                    // if this is the local user herself/himself
    6.43      identity_flags_t flags;     // identity_flag1 | identity_flag2 | ...
    6.44  } pEp_identity;
    6.45  
    6.46 @@ -600,6 +605,66 @@
    6.47          PEP_SESSION session, const pEp_identity *identity
    6.48      );
    6.49  
    6.50 +// get_default own_userid() - get the user_id of the own user
    6.51 +//
    6.52 +//    parameters:
    6.53 +//        session (in)        session handle
    6.54 +//        userid  (out)       own user id (if it exists)
    6.55 +//
    6.56 +//    return value:
    6.57 +//        PEP_STATUS_OK = 0             userid was found
    6.58 +//        PEP_CANNOT_FIND_IDENTITY      no own_user found in the DB
    6.59 +//        PEP_UNKNOWN_ERROR             results were returned, but no ID
    6.60 +//                                      found (no reason this should ever occur)
    6.61 +//    caveat:
    6.62 +//        userid will be NULL if not found; otherwise, returned string
    6.63 +//        belongs to the caller.
    6.64 +
    6.65 +DYNAMIC_API PEP_STATUS get_default_own_userid(
    6.66 +        PEP_SESSION session, 
    6.67 +        char** userid
    6.68 +    );
    6.69 +
    6.70 +// get_userid_alias_default() - get the default user_id which corresponds
    6.71 +//                              to an alias
    6.72 +//    parameters:
    6.73 +//        session (in)        session handle
    6.74 +//        alias_id (in)       the user_id which may be an alias for a default id
    6.75 +//        default_id (out)    the default id for this alias, if the alias
    6.76 +//                            is in the DB as an alias, else NULL
    6.77 +//    return value:
    6.78 +//        PEP_STATUS_OK = 0             userid was found
    6.79 +//        PEP_CANNOT_FIND_ALIAS         this userid is not listed as an 
    6.80 +//                                      alias in the DB
    6.81 +//        PEP_UNKNOWN_ERROR             results were returned, but no ID
    6.82 +//                                      found (no reason this should ever occur)
    6.83 +//    caveat:
    6.84 +//        default_id will be NULL if not found; otherwise, returned string
    6.85 +//        belongs to the caller.
    6.86 +//        also, current implementation does NOT check to see if this userid
    6.87 +//        IS a default.
    6.88 +
    6.89 +DYNAMIC_API PEP_STATUS get_userid_alias_default(
    6.90 +        PEP_SESSION session, 
    6.91 +        const char* alias_id,
    6.92 +        char** default_id);
    6.93 +
    6.94 +// set_userid_alias() - set an alias to correspond to a default id
    6.95 +//    parameters:
    6.96 +//        session (in)        session handle
    6.97 +//        default_id (in)     the default id for this alias. This must
    6.98 +//                            correspond to the default user_id for an
    6.99 +//                            entry in the person (user) table.
   6.100 +//        alias_id (in)       the alias to be set for this default id
   6.101 +//    return value:
   6.102 +//        PEP_STATUS_OK = 0             userid was found
   6.103 +//        PEP_CANNOT_SET_ALIAS          there was an error setting this
   6.104 +
   6.105 +DYNAMIC_API PEP_STATUS set_userid_alias (
   6.106 +        PEP_SESSION session, 
   6.107 +        const char* default_id,
   6.108 +        const char* alias_id);
   6.109 +
   6.110  // set_device_group() - update own person's device group
   6.111  //
   6.112  //    parameters:
   6.113 @@ -853,7 +918,7 @@
   6.114  //  parameters:
   6.115  //      session (in)            session handle
   6.116  //      identity (inout)        user_id and fpr to check as UTF-8 strings (in)
   6.117 -//                              user_id and comm_type as result (out)
   6.118 +//                              comm_type as result (out)
   6.119  //
   6.120  //  this function modifies the given identity struct; the struct remains in
   6.121  //  the ownership of the caller
   6.122 @@ -1127,6 +1192,29 @@
   6.123  
   6.124  DYNAMIC_API PEP_STATUS reset_peptest_hack(PEP_SESSION session);
   6.125  
   6.126 +// This is used internally when there is a temporary identity to be retrieved
   6.127 +// that may not yet have an FPR attached. See get_identity() for functionality,
   6.128 +// params and caveats.
   6.129 +PEP_STATUS get_identity_without_trust_check(
   6.130 +        PEP_SESSION session,
   6.131 +        const char *address,
   6.132 +        const char *user_id,
   6.133 +        pEp_identity **identity
   6.134 +    );
   6.135 +    
   6.136 +PEP_STATUS get_identities_by_address(
   6.137 +        PEP_SESSION session,
   6.138 +        const char *address,
   6.139 +        identity_list** id_list
   6.140 +    );
   6.141 +        
   6.142 +PEP_STATUS replace_userid(PEP_SESSION session, const char* old_uid,
   6.143 +                              const char* new_uid);
   6.144 +                              
   6.145 +PEP_STATUS remove_fpr_as_default(PEP_SESSION session, 
   6.146 +                                    const char* fpr);
   6.147 +                              
   6.148 +    
   6.149  #ifdef __cplusplus
   6.150  }
   6.151  #endif
     7.1 --- a/src/pEp_internal.h	Wed Jan 17 11:16:22 2018 +0100
     7.2 +++ b/src/pEp_internal.h	Thu Jan 18 00:46:19 2018 +0100
     7.3 @@ -123,7 +123,10 @@
     7.4      sqlite3_stmt *log;
     7.5      sqlite3_stmt *trustword;
     7.6      sqlite3_stmt *get_identity;
     7.7 +    sqlite3_stmt *get_identity_without_trust_check;
     7.8 +    sqlite3_stmt *get_identities_by_address;
     7.9      sqlite3_stmt *replace_identities_fpr;
    7.10 +    sqlite3_stmt *remove_fpr_as_default;
    7.11      sqlite3_stmt *set_person;
    7.12      sqlite3_stmt *set_device_group;
    7.13      sqlite3_stmt *get_device_group;
    7.14 @@ -140,6 +143,7 @@
    7.15      sqlite3_stmt *crashdump;
    7.16      sqlite3_stmt *languagelist;
    7.17      sqlite3_stmt *i18n_token;
    7.18 +    sqlite3_stmt *replace_userid;
    7.19  
    7.20      // blacklist
    7.21      sqlite3_stmt *blacklist_add;
    7.22 @@ -151,7 +155,11 @@
    7.23      sqlite3_stmt *own_key_is_listed;
    7.24      sqlite3_stmt *own_identities_retrieve;
    7.25      sqlite3_stmt *own_keys_retrieve;
    7.26 -    sqlite3_stmt *set_own_key;
    7.27 +    sqlite3_stmt *get_user_default_key;
    7.28 +        
    7.29 +    sqlite3_stmt *get_default_own_userid;
    7.30 +
    7.31 +//    sqlite3_stmt *set_own_key;
    7.32  
    7.33      // sequence value
    7.34      sqlite3_stmt *sequence_value1;
    7.35 @@ -162,6 +170,10 @@
    7.36      sqlite3_stmt *set_revoked;
    7.37      sqlite3_stmt *get_revoked;
    7.38  
    7.39 +    // aliases
    7.40 +    sqlite3_stmt *get_userid_alias_default;
    7.41 +    sqlite3_stmt *add_userid_alias;
    7.42 +
    7.43      // callbacks
    7.44      examine_identity_t examine_identity;
    7.45      void *examine_management;
    7.46 @@ -339,13 +351,6 @@
    7.47      return comparison == 0;
    7.48  }
    7.49  
    7.50 -static inline bool _identity_me(
    7.51 -        pEp_identity * identity
    7.52 -    )
    7.53 -{
    7.54 -    return identity->user_id && strcmp(identity->user_id, PEP_OWN_USERID) == 0;
    7.55 -}
    7.56 -
    7.57  // size is the length of the bytestr that's coming in. This is really only intended
    7.58  // for comparing two full strings. If charstr's length is different from bytestr_size,
    7.59  // we'll return a non-zero value.
    7.60 @@ -368,6 +373,20 @@
    7.61  #endif
    7.62  }
    7.63  
    7.64 +static inline bool is_me(PEP_SESSION session, pEp_identity* test_ident) {
    7.65 +    bool retval = false;
    7.66 +    if (test_ident && test_ident->user_id) {
    7.67 +        char* def_id = NULL;
    7.68 +        get_default_own_userid(session, &def_id);
    7.69 +        if (test_ident->me || 
    7.70 +            (def_id && strcmp(def_id, test_ident->user_id) == 0)) {
    7.71 +            retval = true;
    7.72 +        }
    7.73 +        free(def_id);
    7.74 +    }
    7.75 +    return retval;
    7.76 +}
    7.77 +
    7.78  // These are globals used in generating message IDs and should only be
    7.79  // computed once, as they're either really constants or OS-dependent
    7.80  
     8.1 --- a/src/sync_actions.c	Wed Jan 17 11:16:22 2018 +0100
     8.2 +++ b/src/sync_actions.c	Thu Jan 18 00:46:19 2018 +0100
     8.3 @@ -56,8 +56,14 @@
     8.4      // key created first wins
     8.5  
     8.6      Identity me = NULL;
     8.7 -    PEP_STATUS status = get_identity(session, partner->address, PEP_OWN_USERID,
     8.8 -            &me);
     8.9 +    
    8.10 +    char* own_id = NULL;
    8.11 +    PEP_STATUS status = get_default_own_userid(session, &own_id);
    8.12 +    if (own_id) {
    8.13 +        status = get_identity(session, partner->address, own_id,
    8.14 +                              &me);
    8.15 +        free(own_id);
    8.16 +    }
    8.17      if (status == PEP_OUT_OF_MEMORY)
    8.18          return invalid_out_of_memory;
    8.19      if (status != PEP_STATUS_OK)
    8.20 @@ -142,9 +148,15 @@
    8.21      if (!session->notifyHandshake)
    8.22          return PEP_SYNC_NO_NOTIFY_CALLBACK;
    8.23  
    8.24 +    char* own_id = NULL;
    8.25 +    status = get_default_own_userid(session, &own_id);
    8.26 +        
    8.27      // notifyHandshake take ownership of given identities
    8.28      pEp_identity *me = NULL;
    8.29 -    status = get_identity(session, partner->address, PEP_OWN_USERID, &me);
    8.30 +    if (own_id) {
    8.31 +        status = get_identity(session, partner->address, own_id, &me);
    8.32 +        free(own_id);
    8.33 +    }
    8.34      if (status != PEP_STATUS_OK)
    8.35          goto error;
    8.36      
    8.37 @@ -235,16 +247,23 @@
    8.38      )
    8.39  {
    8.40      PEP_STATUS status = PEP_STATUS_OK;
    8.41 -
    8.42 +    
    8.43 +    char* own_id = NULL;
    8.44 +    status = get_default_own_userid(session, &own_id);
    8.45 +    
    8.46 +    // FIXME: Is this where and what we wanna do with this?
    8.47 +    if (status != PEP_STATUS_OK)
    8.48 +        return status;
    8.49 +        
    8.50      for (identity_list *il = group_keys; il && il->ident; il = il->next) {
    8.51  
    8.52 -        if (strcmp(il->ident->user_id, PEP_OWN_USERID)!=0) {
    8.53 +        if (strcmp(il->ident->user_id, own_id)!=0) {
    8.54              assert(0);
    8.55              continue;
    8.56          }
    8.57          // Check that identity isn't excluded from sync.
    8.58          pEp_identity *stored_identity = NULL;
    8.59 -        status = get_identity(session, il->ident->address, PEP_OWN_USERID,
    8.60 +        status = get_identity(session, il->ident->address, own_id,
    8.61                  &stored_identity);
    8.62          if (status == PEP_STATUS_OK) {
    8.63              if(stored_identity->flags & PEP_idf_not_for_sync){
    8.64 @@ -258,7 +277,8 @@
    8.65          if (status != PEP_STATUS_OK)
    8.66              break;
    8.67      }
    8.68 -
    8.69 +    
    8.70 +    free(own_id);
    8.71      return status;
    8.72  }
    8.73      
     9.1 --- a/src/sync_impl.c	Wed Jan 17 11:16:22 2018 +0100
     9.2 +++ b/src/sync_impl.c	Thu Jan 18 00:46:19 2018 +0100
     9.3 @@ -275,16 +275,25 @@
     9.4      // partner identity must be explicitely added DB to later
     9.5      // be able to communicate securely with it.
     9.6      if(partner){
     9.7 +        
     9.8 +        char* own_id = NULL;
     9.9 +        status = get_default_own_userid(session, &own_id);
    9.10 +        
    9.11 +        if (!own_id)
    9.12 +            own_id = strdup(PEP_OWN_USERID);
    9.13 +            
    9.14          // protect virtual user IDs 
    9.15          if((strncmp("TOFU_", partner->user_id, 6) == 0 &&
    9.16             strlen(partner->user_id) == strlen(partner->address) + 6 &&
    9.17             strcmp(partner->user_id + 6, partner->address)) ||
    9.18          // protect own ID 
    9.19 -           (strcmp(PEP_OWN_USERID, partner->user_id) == 0)){
    9.20 +           (strcmp(own_id, partner->user_id) == 0)){
    9.21              status = PEP_SYNC_ILLEGAL_MESSAGE;
    9.22 +            free(own_id);
    9.23              goto error;
    9.24          }
    9.25  
    9.26 +        free(own_id);
    9.27          // partner IDs are UUIDs bound to session lifespan
    9.28          // and therefore partner identities are not supposed
    9.29          // to mutate over time, but just not be used anymore.
    9.30 @@ -426,6 +435,9 @@
    9.31      bool discard = false;
    9.32      bool force_keep_msg = false;
    9.33  
    9.34 +    char* own_id = NULL;
    9.35 +    PEP_STATUS own_id_status = get_default_own_userid(session, &own_id);
    9.36 +
    9.37      for (bloblist_t *bl = src->attachments; bl && bl->value; bl = bl->next) {
    9.38          if (bl->mime_type && strcasecmp(bl->mime_type, "application/pEp.sync") == 0
    9.39                  && bl->size) {
    9.40 @@ -451,11 +463,18 @@
    9.41                              msg->header.me.address->size);
    9.42  
    9.43                  if(null_terminated_address){
    9.44 -                    status = get_identity(session, 
    9.45 -                                          null_terminated_address, 
    9.46 -                                          PEP_OWN_USERID, 
    9.47 -                                          &check_me);
    9.48 -                    free(null_terminated_address);
    9.49 +                    
    9.50 +                    if (own_id) {                        
    9.51 +                        status = get_identity(session, 
    9.52 +                                              null_terminated_address, 
    9.53 +                                              own_id, 
    9.54 +                                              &check_me);
    9.55 +                        free(null_terminated_address);
    9.56 +
    9.57 +                    }
    9.58 +                    else {
    9.59 +                        status = own_id_status;
    9.60 +                    }
    9.61                  } 
    9.62                  else
    9.63                      status = PEP_OUT_OF_MEMORY;
    9.64 @@ -608,10 +627,23 @@
    9.65                              // GroupUpdate and UpdateRequests come from group.
    9.66                              // check trust relation in between signer key and 
    9.67                              // own id to be sure.
    9.68 -                            pEp_identity *_from = new_identity(NULL, 
    9.69 -                                                               keylist->value,
    9.70 -                                                               PEP_OWN_USERID,
    9.71 -                                                               NULL);
    9.72 +                            
    9.73 +                            if (status != PEP_STATUS_OK)
    9.74 +                                goto free_all;
    9.75 +                            
    9.76 +                            pEp_identity* _from = NULL;
    9.77 +                            
    9.78 +                            if (own_id) {    
    9.79 +                                _from = new_identity(NULL, 
    9.80 +                                                     keylist->value,
    9.81 +                                                     own_id,
    9.82 +                                                     NULL);
    9.83 +                            }
    9.84 +                            else {
    9.85 +                                status = own_id_status;
    9.86 +                                goto free_all;
    9.87 +                            }
    9.88 +                            
    9.89                              if (_from == NULL){
    9.90                                  status = PEP_OUT_OF_MEMORY;
    9.91                                  goto free_all;
    9.92 @@ -658,7 +690,7 @@
    9.93                  ASN_STRUCT_FREE(asn_DEF_DeviceGroup_Protocol, msg);
    9.94              free_userid:
    9.95                  free(user_id);
    9.96 -
    9.97 +                free(own_id);
    9.98                  if (status != PEP_STATUS_OK)
    9.99                      return status;
   9.100              }
   9.101 @@ -765,10 +797,15 @@
   9.102          goto error;
   9.103      }
   9.104  
   9.105 +    char* own_id = NULL;
   9.106 +    status = get_default_own_userid(session, &own_id);
   9.107 +    if (status != PEP_STATUS_OK)
   9.108 +        goto error;
   9.109 +
   9.110      msg->header.version.major = SYNC_VERSION_MAJOR;
   9.111      msg->header.version.minor = SYNC_VERSION_MINOR;
   9.112  
   9.113 -    status = get_identity(session, partner->address, PEP_OWN_USERID, &me);
   9.114 +    status = get_identity(session, partner->address, own_id, &me);
   9.115      if (status != PEP_STATUS_OK)
   9.116          goto error;
   9.117      
   9.118 @@ -889,6 +926,7 @@
   9.119      free(payload);
   9.120      free_message(_message);
   9.121      free_identity(me);
   9.122 +    free(own_id);
   9.123      return status;
   9.124  }
   9.125  
    10.1 --- a/test/apple_mail_test.cc	Wed Jan 17 11:16:22 2018 +0100
    10.2 +++ b/test/apple_mail_test.cc	Thu Jan 18 00:46:19 2018 +0100
    10.3 @@ -34,9 +34,11 @@
    10.4          
    10.5      const string mailtext = slurp(mailfile);
    10.6      pEp_identity * me = new_identity("pep.test.recip@kgrothoff.org", "93D19F24AD6F4C4BA9134AAF84D9217908DB0AEE", PEP_OWN_USERID, "pEp Test Recipient");    
    10.7 +    me->me = true;    
    10.8      PEP_STATUS status = myself(session, me);
    10.9      
   10.10      pEp_identity * you = new_identity("pep.test.apple@pep-project.org", NULL, "TOFU_pep.test.apple@pep-project.org", "pEp Test Recipient");    
   10.11 +    you->me = false;    
   10.12      status = update_identity(session, you);
   10.13  
   10.14      trust_personal_key(session, you);
   10.15 @@ -53,7 +55,12 @@
   10.16      status = mime_decode_message(mailtext.c_str(), mailtext.length(), &msg_ptr);
   10.17      assert(status == PEP_STATUS_OK);
   10.18      assert(msg_ptr);
   10.19 +    
   10.20 +    update_identity(session, msg_ptr->from);
   10.21 +    update_identity(session, msg_ptr->to->ident);
   10.22 +    
   10.23      final_ptr = msg_ptr;
   10.24 +    
   10.25      status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
   10.26      final_ptr = dest_msg ? dest_msg : msg_ptr;
   10.27    
    11.1 --- a/test/blacklist_test.cc	Wed Jan 17 11:16:22 2018 +0100
    11.2 +++ b/test/blacklist_test.cc	Thu Jan 18 00:46:19 2018 +0100
    11.3 @@ -64,6 +64,7 @@
    11.4      cout << "23 is not listed any more.\n";
    11.5  
    11.6      cout << "blacklist only key for identity / unblacklist key / add key" << endl;
    11.7 +
    11.8      
    11.9      // 2797 65A2 FEB5 B7C7 31B8  61D9 3E4C EFD9 F7AF 4684 - this is the blacklisted key in blacklisted_pub.asc
   11.10  
   11.11 @@ -75,8 +76,15 @@
   11.12      PEP_STATUS status7 = import_key(session, keytext.c_str(), keytext.length(), NULL);
   11.13      
   11.14      const char* bl_fpr_1 = "279765A2FEB5B7C731B861D93E4CEFD9F7AF4684";
   11.15 -    const char* bl_fpr_2 = "634FAC4417E9B2A5DC2BD4AAC4AEEBBE7E62701B";
   11.16 +    const char* bl_fpr_2 = "634FAC4417E9B2A5DC2BD4AAC4AEEBBE7E62701B"; 
   11.17      bool is_blacklisted = false;
   11.18 +
   11.19 +    // Clean up from previous runs
   11.20 +    PEP_STATUS status10 = blacklist_is_listed(session, bl_fpr_1, &is_blacklisted);
   11.21 +    if (is_blacklisted) {
   11.22 +        is_blacklisted = false;
   11.23 +        blacklist_delete(session, bl_fpr_1);
   11.24 +    }
   11.25      
   11.26      pEp_identity* blacklisted_identity = new_identity("blacklistedkeys@kgrothoff.org",
   11.27                                                        bl_fpr_1,
   11.28 @@ -85,7 +93,9 @@
   11.29  
   11.30      PEP_STATUS status8 = update_identity(session, blacklisted_identity);
   11.31      
   11.32 -    blacklisted_identity->comm_type = PEP_ct_pEp;
   11.33 +    // THERE IS NO BLACKLISTING OF PEP KEYS
   11.34 +    //blacklisted_identity->comm_type = PEP_ct_pEp;
   11.35 +    blacklisted_identity->comm_type = PEP_ct_OpenPGP_unconfirmed;
   11.36  
   11.37      PEP_STATUS status99 = set_identity(session, blacklisted_identity);
   11.38      
   11.39 @@ -93,16 +103,23 @@
   11.40  
   11.41      PEP_STATUS status999 = update_identity(session, blacklisted_identity);
   11.42  
   11.43 -    assert(blacklisted_identity->comm_type == PEP_ct_pEp);
   11.44 +    assert(blacklisted_identity->comm_type == PEP_ct_OpenPGP);
   11.45  
   11.46      PEP_STATUS status9 = blacklist_add(session, bl_fpr_1);
   11.47 -    PEP_STATUS status10 = blacklist_is_listed(session, bl_fpr_1, &is_blacklisted);
   11.48 +    status10 = blacklist_is_listed(session, bl_fpr_1, &is_blacklisted);
   11.49      PEP_STATUS status11 = update_identity(session, blacklisted_identity);
   11.50 +    if (!(blacklisted_identity->fpr))
   11.51 +        cout << "OK! blacklisted_identity->fpr is empty. Yay!" << endl;
   11.52 +    else if (strcmp(blacklisted_identity->fpr, bl_fpr_2) == 0)
   11.53 +        cout << "OK! While this should be empty, you are probably running " << 
   11.54 +                "this in your home directory instead of the test environment " << 
   11.55 +                "and have leftover keys. This is an acceptable result here then. But you " <<
   11.56 +                "should probably clean up after yourself :)" << endl;
   11.57 +    else
   11.58 +        cout << "Not OK. blacklisted_identity->fpr is " << blacklisted_identity->fpr << "." << endl
   11.59 +             << "Expected it to be empty or (possibly) " << bl_fpr_2 << endl;
   11.60 +    assert(!(blacklisted_identity->fpr) || blacklisted_identity->fpr[0] == '\0'|| (strcmp(blacklisted_identity->fpr, bl_fpr_2) == 0));
   11.61  
   11.62 -    if (strcmp(blacklisted_identity->fpr, ""))
   11.63 -        cout << "blacklisted_identity-> fpr should be empty, but is " << blacklisted_identity->fpr << endl;
   11.64 -    else
   11.65 -        cout << "blacklisted identity's fpr successfully wiped by update_identity" << endl;
   11.66  
   11.67      const string keytext2 = slurp("blacklisted_pub2.asc");
   11.68      PEP_STATUS status14 = import_key(session, keytext2.c_str(), keytext2.length(), NULL);
   11.69 @@ -113,10 +130,11 @@
   11.70                                                         "Blacklist Keypair");
   11.71      PEP_STATUS status15 = update_identity(session, blacklisted_identity2);
   11.72  
   11.73 -    if (strcmp(blacklisted_identity->fpr, bl_fpr_2) == 0)
   11.74 +    assert(blacklisted_identity2->fpr && strcmp(blacklisted_identity2->fpr, bl_fpr_2) == 0);
   11.75 +    if (blacklisted_identity2->fpr && strcmp(blacklisted_identity2->fpr, bl_fpr_2) == 0)
   11.76          cout << "blacklisted identity's fpr successfully replaced by the unblacklisted one" << endl;
   11.77 -    else
   11.78 -        cout << "blacklisted_identity->fpr should be " << bl_fpr_2 << " but is " << blacklisted_identity->fpr << endl;
   11.79 +    // else
   11.80 +    //     cout << "blacklisted_identity->fpr should be " << bl_fpr_2 << " but is " << blacklisted_identity->fpr << endl;
   11.81      
   11.82      PEP_STATUS status12 = blacklist_delete(session, bl_fpr_1);
   11.83      PEP_STATUS status13 = update_identity(session, blacklisted_identity);
    12.1 --- a/test/case_and_dot_address_test.cc	Wed Jan 17 11:16:22 2018 +0100
    12.2 +++ b/test/case_and_dot_address_test.cc	Thu Jan 18 00:46:19 2018 +0100
    12.3 @@ -39,36 +39,42 @@
    12.4      assert(statuspub == PEP_STATUS_OK);
    12.5      assert(statuspriv == PEP_STATUS_OK);
    12.6  
    12.7 -    pEp_identity * alice_id = new_identity("pep.test.alice@pep-project.org", NULL, PEP_OWN_USERID, "Alice Test");
    12.8 -    status = update_identity(session, alice_id);
    12.9 -    assert(alice_id->fpr);
   12.10 -    assert(strcmp(alice_id->fpr, "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97") == 0);
   12.11 +    pEp_identity * alice_id = new_identity("pep.test.alice@pep-project.org", "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97", PEP_OWN_USERID, "Alice Test");
   12.12 +    identity_list* own_id = new_identity_list(alice_id);
   12.13 +    status = initialise_own_identities(session, own_id);
   12.14 +    status = trust_personal_key(session, alice_id);
   12.15 +    pEp_identity * new_alice_id = new_identity("pep.test.alice@pep-project.org", "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97", PEP_OWN_USERID, "Alice Test");
   12.16 +    status = update_identity(session, new_alice_id);
   12.17 +    assert(new_alice_id->fpr);
   12.18 +    assert(strcmp(new_alice_id->fpr, "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97") == 0);
   12.19 +    free_identity(new_alice_id);
   12.20      free_identity(alice_id);
   12.21      alice_id = NULL;
   12.22 +    new_alice_id = NULL;
   12.23  
   12.24      alice_id = new_identity(alice_email_case, NULL, PEP_OWN_USERID, "Alice Test");
   12.25 -    status = update_identity(session, alice_id);
   12.26 +    status = myself(session, alice_id);
   12.27      assert(alice_id->fpr);
   12.28      assert(strcmp(alice_id->fpr, "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97") == 0);
   12.29      free_identity(alice_id);
   12.30      alice_id = NULL;
   12.31  
   12.32      alice_id = new_identity(alice_email_dot, NULL, PEP_OWN_USERID, "Alice Test");
   12.33 -    status = update_identity(session, alice_id);
   12.34 +    status = myself(session, alice_id);
   12.35      assert(alice_id->fpr);
   12.36      assert(strcmp(alice_id->fpr, "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97") == 0);
   12.37      free_identity(alice_id);
   12.38      alice_id = NULL;
   12.39  
   12.40      alice_id = new_identity(alice_email_dotless, NULL, PEP_OWN_USERID, "Alice Test");
   12.41 -    status = update_identity(session, alice_id);
   12.42 +    status = myself(session, alice_id);
   12.43      assert(alice_id->fpr);
   12.44      assert(strcmp(alice_id->fpr, "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97") == 0);
   12.45      free_identity(alice_id);
   12.46      alice_id = NULL;
   12.47  
   12.48      alice_id = new_identity(alice_email_case_and_dot, NULL, PEP_OWN_USERID, "Alice Test");
   12.49 -    status = update_identity(session, alice_id);
   12.50 +    status = myself(session, alice_id);
   12.51      assert(alice_id->fpr);
   12.52      assert(strcmp(alice_id->fpr, "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97") == 0);
   12.53      free_identity(alice_id);
    13.1 --- a/test/decorate_test.cc	Wed Jan 17 11:16:22 2018 +0100
    13.2 +++ b/test/decorate_test.cc	Thu Jan 18 00:46:19 2018 +0100
    13.3 @@ -10,6 +10,7 @@
    13.4  #include <sstream>
    13.5  #include "mime.h"
    13.6  #include "message_api.h"
    13.7 +#include "test_util.h"
    13.8  
    13.9  using namespace std;
   13.10  
   13.11 @@ -24,11 +25,20 @@
   13.12      assert(session);
   13.13      cout << "init() completed.\n";
   13.14  
   13.15 -    // message_api test code
   13.16 +    const string alice_pub_key = slurp("test_keys/pub/pep-test-alice-0x6FF00E97_pub.asc");
   13.17 +    const string alice_priv_key = slurp("test_keys/priv/pep-test-alice-0x6FF00E97_priv.asc");
   13.18 +    const string bob_pub_key = slurp("test_keys/pub/pep-test-bob-0xC9C2EE39_pub.asc");
   13.19 +    PEP_STATUS statuspub = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL);
   13.20 +    PEP_STATUS statuspriv = import_key(session, alice_priv_key.c_str(), alice_priv_key.length(), NULL);
   13.21 +    PEP_STATUS statusbob = import_key(session, bob_pub_key.c_str(), bob_pub_key.length(), NULL);
   13.22 +    assert(statuspub == PEP_STATUS_OK);
   13.23 +    assert(statuspriv == PEP_STATUS_OK);
   13.24 +    assert(statusbob == PEP_STATUS_OK);
   13.25  
   13.26      cout << "creating message…\n";
   13.27      pEp_identity* alice = new_identity("pep.test.alice@pep-project.org", NULL, PEP_OWN_USERID, "Alice Test");
   13.28      pEp_identity* bob = new_identity("pep.test.bob@pep-project.org", NULL, "42", "Bob Test");
   13.29 +    alice->me = true;
   13.30      identity_list* to_list = new_identity_list(bob); // to bob
   13.31      message* outgoing_message = new_message(PEP_dir_outgoing);
   13.32      assert(outgoing_message);
   13.33 @@ -45,7 +55,7 @@
   13.34      message* encrypted_msg = nullptr;
   13.35      cout << "calling encrypt_message\n";
   13.36      PEP_STATUS status = encrypt_message (session, outgoing_message, NULL, &encrypted_msg, PEP_enc_PGP_MIME, 0);
   13.37 -    cout << "encrypt_message() returns " << std::hex << status << '.' << endl;
   13.38 +    cout << "encrypt_message() returns " << tl_status_string(status) << '.' << endl;
   13.39      assert(status == PEP_STATUS_OK);
   13.40      assert(encrypted_msg);
   13.41      cout << "message encrypted.\n";
    14.1 --- a/test/encrypt_for_identity_test.cc	Wed Jan 17 11:16:22 2018 +0100
    14.2 +++ b/test/encrypt_for_identity_test.cc	Thu Jan 18 00:46:19 2018 +0100
    14.3 @@ -38,6 +38,7 @@
    14.4      cout << "creating message…\n";
    14.5      pEp_identity* alice = new_identity("pep.test.alice@pep-project.org", "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97", PEP_OWN_USERID, "Alice Test");
    14.6      pEp_identity* bob = new_identity("pep.test.bob@pep-project.org", NULL, "42", "Bob Test");
    14.7 +    alice->me = true;
    14.8  
    14.9      PEP_STATUS mystatus = myself(session, alice);
   14.10      assert(mystatus == PEP_STATUS_OK);
    15.1 --- a/test/encrypt_missing_private_key_test.cc	Wed Jan 17 11:16:22 2018 +0100
    15.2 +++ b/test/encrypt_missing_private_key_test.cc	Thu Jan 18 00:46:19 2018 +0100
    15.3 @@ -25,46 +25,33 @@
    15.4      assert(status1 == PEP_STATUS_OK);
    15.5      assert(session);
    15.6      cout << "init() completed.\n";
    15.7 -
    15.8 -    // blacklist test code
    15.9 -
   15.10 -    cout << "blacklist only key for identity / add key / check which key is used" << endl;
   15.11      
   15.12 -    // B252066DE0513BECA2954F30E8E18177B28D9B9D - this is the blacklisted key in blacklisted_self.asc
   15.13 -
   15.14 -    const string keytext = slurp("test_keys/priv/blacklist_self.asc");
   15.15 -    
   15.16 -    /* import it into pep */
   15.17 -    PEP_STATUS status7 = import_key(session, keytext.c_str(), keytext.length(), NULL);
   15.18 -    
   15.19 -    const char* bl_fpr_1 = "B252066DE0513BECA2954F30E8E18177B28D9B9D";
   15.20 -    bool is_blacklisted = false;
   15.21 -    
   15.22 -    pEp_identity* blacklisted_identity = new_identity("blacklistself@kgrothoff.org",
   15.23 -                                                      bl_fpr_1,
   15.24 +    pEp_identity* no_key_identity = new_identity("blacklistself@kgrothoff.org",
   15.25 +                                                      NULL,
   15.26                                                        PEP_OWN_USERID,
   15.27                                                        "Blacklist Self");
   15.28 -    PEP_STATUS status8 = myself(session, blacklisted_identity);
   15.29 +    no_key_identity->me = true;
   15.30 +    PEP_STATUS status8 = myself(session, no_key_identity);
   15.31      assert (status8 == PEP_STATUS_OK);
   15.32 -    PEP_STATUS status9 = blacklist_add(session, bl_fpr_1);
   15.33 -    assert (status9 == PEP_STATUS_OK);
   15.34 -    PEP_STATUS status10 = blacklist_is_listed(session, bl_fpr_1, &is_blacklisted);
   15.35 -    assert (status10 == PEP_STATUS_OK);
   15.36 -    PEP_STATUS status11 = myself(session, blacklisted_identity);
   15.37 -    assert (status11 == PEP_STATUS_OK);
   15.38  
   15.39 -    /* identity is blacklisted. Now let's try to encrypt a message. */
   15.40 -    
   15.41 -    const char* new_key = NULL;
   15.42 -    
   15.43 -    const string mailtext = slurp("test_mails/blacklist_no_key.eml");
   15.44 -    
   15.45 +    /* Now let's try to encrypt a message. */
   15.46 +        
   15.47      message* tmp_msg = NULL;
   15.48      message* enc_msg = NULL;
   15.49      
   15.50 +    const string mailtext = slurp("test_mails/blacklist_no_key.eml");
   15.51 +
   15.52      PEP_STATUS status = mime_decode_message(mailtext.c_str(), mailtext.length(), &tmp_msg);
   15.53      assert(status == PEP_STATUS_OK);
   15.54      
   15.55 +    status = update_identity(session, tmp_msg->from);
   15.56 +    identity_list* to_list = tmp_msg->to;
   15.57 +
   15.58 +    while (to_list) {
   15.59 +        if (to_list->ident)
   15.60 +            update_identity(session, to_list->ident);
   15.61 +        to_list = to_list->next;
   15.62 +    }
   15.63      
   15.64      // This isn't incoming, though... so we need to reverse the direction
   15.65      tmp_msg->dir = PEP_dir_outgoing;
   15.66 @@ -76,30 +63,12 @@
   15.67                               0);
   15.68      assert(status == PEP_STATUS_OK);
   15.69      
   15.70 -//    PEP_STATUS status69 = MIME_encrypt_message(session, mailtext.c_str(), mailtext.length(), NULL, &enc_msg, PEP_enc_PGP_MIME, 0);
   15.71 -//    pEp_identity * me1 = new_identity("blacklist_test@kgrothoff.org", NULL, PEP_OWN_USERID, "Blacklisted Key Message Recipient");    
   15.72  
   15.73 -    new_key = enc_msg->from->fpr;
   15.74 +    char* new_key = enc_msg->from->fpr;
   15.75      cout << "Encrypted with key " << new_key << endl;
   15.76 -    assert (strcasecmp(new_key, bl_fpr_1) != 0);
   15.77 -//     PEP_STATUS status = update_identity(session, me1);
   15.78 -//     message* msg_ptr = nullptr;
   15.79 -//     message* dest_msg = nullptr;
   15.80 -//     stringlist_t* keylist = nullptr;
   15.81 -//     PEP_rating rating;
   15.82 -//     PEP_decrypt_flags_t flags;
   15.83 -//     
   15.84 -//     status = mime_decode_message(mailtext.c_str(), mailtext.length(), &msg_ptr);
   15.85 -//     assert(status == PEP_STATUS_OK);
   15.86 -//     status = decrypt_message(session, msg_ptr, &dest_msg, &keylist, &rating, &flags);
   15.87 -// 
   15.88 -//     PEP_STATUS status12 = update_identity(session, blacklisted_identity);
   15.89 -// 
   15.90 -//     assert(strcasecmp(blacklisted_identity->fpr, new_key) == 0);
   15.91      
   15.92      status = delete_keypair(session, new_key);
   15.93 -    PEP_STATUS status13 = blacklist_delete(session, bl_fpr_1);
   15.94 -    PEP_STATUS status14 = update_identity(session, blacklisted_identity);
   15.95 +    PEP_STATUS status14 = myself(session, no_key_identity);
   15.96  
   15.97      free_message(tmp_msg);    
   15.98      free_message(enc_msg);
    16.1 --- a/test/external_revoke_test.cc	Wed Jan 17 11:16:22 2018 +0100
    16.2 +++ b/test/external_revoke_test.cc	Thu Jan 18 00:46:19 2018 +0100
    16.3 @@ -45,7 +45,6 @@
    16.4      status = myself(session, me);
    16.5      
    16.6      // Create key
    16.7 -
    16.8      cout << "Creating new id for : ";
    16.9      char *uniqname = strdup("AAAAtestuser@testdomain.org");
   16.10      srandom(time(NULL));
   16.11 @@ -71,6 +70,7 @@
   16.12      cout << "---------------------------------------------------------" << endl << endl;
   16.13  
   16.14      cout << "Trusting personal key for " << uniqname << endl;
   16.15 +    recip1->me = false;
   16.16      // Trust it
   16.17      status = update_identity(session, recip1);
   16.18      status = trust_personal_key(session, recip1);
   16.19 @@ -179,53 +179,27 @@
   16.20  
   16.21      status = encrypt_message(session, outgoing_msg, NULL, &encrypted_outgoing_msg, PEP_enc_PGP_MIME, 0);
   16.22      cout << "Encryption returns with status " << tl_status_string(status) << endl;
   16.23 -
   16.24 -    PEP_comm_type ct = (encrypted_outgoing_msg ? encrypted_outgoing_msg->to->ident->comm_type : outgoing_msg->to->ident->comm_type);
   16.25 +    assert (status == PEP_KEY_UNSUITABLE);
   16.26 +    assert (encrypted_outgoing_msg == NULL);
   16.27 +    status = update_identity(session, recip1);
   16.28 +    assert (recip1->comm_type = PEP_ct_key_revoked);
   16.29  
   16.30      cout << endl << "---------------------------------------------------------" << endl;
   16.31      cout << "2c. Check trust of recip, whose only key has been revoked, once an encryption attempt has been made." << endl;
   16.32      cout << "---------------------------------------------------------" << endl << endl;
   16.33  
   16.34 -    // check comm_type
   16.35 -    cout << "comm_type: " << tl_ct_string(ct) << endl;
   16.36 -    assert(ct == PEP_ct_key_revoked);
   16.37 -    
   16.38 +    assert(recip1->fpr == NULL);
   16.39 +    recip1->fpr = fprs[0];
   16.40      status = get_trust(session, recip1);
   16.41 +    recip1->fpr = NULL;
   16.42  
   16.43      cout << "Recip's trust DB comm_type = " << hex << tl_ct_string(recip1->comm_type) << endl;
   16.44      assert(recip1->comm_type == PEP_ct_key_revoked);
   16.45  
   16.46 -    cout << endl << "---------------------------------------------------------" << endl;
   16.47 -    cout << "2d. Try to decrypt message that was encrypted for revoked key guy." << endl;
   16.48 -    cout << "---------------------------------------------------------" << endl << endl;
   16.49 -    // decrypt message
   16.50 -//    free_message(outgoing_msg);
   16.51 -//    outgoing_msg = NULL;
   16.52 -    // FIXME: Make this make more sense
   16.53 -    status = decrypt_message(session, outgoing_msg, &decrypted_msg, &keylist, &rating, &flags);
   16.54 -    cout << "Decryption returns with status " << tl_status_string(status) << endl;
   16.55 -    assert(status == PEP_UNENCRYPTED);
   16.56 -    
   16.57 -    // check rating
   16.58 -    cout << "Rating of decrypted message to trusted recip: " << tl_rating_string(rating) << endl;
   16.59 -    assert(rating == PEP_rating_unencrypted);
   16.60 -
   16.61 -    ct = (decrypted_msg ? decrypted_msg->to->ident->comm_type : outgoing_msg->to->ident->comm_type);
   16.62 -
   16.63 -    cout << "comm_type: " << tl_ct_string(ct) << endl;
   16.64 -    assert(ct == PEP_ct_key_revoked);
   16.65 -    
   16.66 -    status = get_trust(session, recip1);
   16.67 -    
   16.68 -    cout << "Recip's trust DB comm_type = " << hex << tl_ct_string(recip1->comm_type) << endl;
   16.69 -    assert(recip1->comm_type == PEP_ct_key_revoked);
   16.70 -
   16.71 -    free_message(encrypted_outgoing_msg);
   16.72      free_message(decrypted_msg);
   16.73      free_message(outgoing_msg);
   16.74      outgoing_msg = NULL;
   16.75      decrypted_msg = NULL;
   16.76 -    encrypted_outgoing_msg = NULL;
   16.77  
   16.78      cout << endl << "---------------------------------------------------------" << endl;
   16.79      cout << "3a. Generate new key, but don't explicitly trust it." << endl;
   16.80 @@ -261,7 +235,7 @@
   16.81      cout << "Message created.\n";
   16.82  
   16.83      status = encrypt_message(session, outgoing_msg, NULL, &encrypted_outgoing_msg, PEP_enc_PGP_MIME, 0);
   16.84 -    ct = (encrypted_outgoing_msg ? encrypted_outgoing_msg->to->ident->comm_type : outgoing_msg->to->ident->comm_type);
   16.85 +    PEP_comm_type ct = (encrypted_outgoing_msg ? encrypted_outgoing_msg->to->ident->comm_type : outgoing_msg->to->ident->comm_type);
   16.86      
   16.87  
   16.88      // CHECK STATUS???
   16.89 @@ -273,8 +247,8 @@
   16.90      
   16.91      status = get_trust(session, recip1);
   16.92  
   16.93 -    cout << "Recip's trust DB comm_type = " << hex << tl_ct_string(recip1->comm_type) << endl;
   16.94 -    assert(recip1->comm_type == PEP_ct_OpenPGP_unconfirmed);
   16.95 +    cout << "Recip's trust DB comm_type (should be unknown, as we're using a keyring-only key, not in DB) = " << hex << tl_ct_string(recip1->comm_type) << endl;
   16.96 +    assert(recip1->comm_type != PEP_ct_OpenPGP_unconfirmed);
   16.97  
   16.98      // decrypt message
   16.99  //    free_message(outgoing_msg);
  16.100 @@ -302,8 +276,8 @@
  16.101      
  16.102      status = get_trust(session, recip1);
  16.103      
  16.104 -    cout << "Recip's trust DB comm_type = " << hex << tl_ct_string(recip1->comm_type) << endl;
  16.105 -    assert(recip1->comm_type == PEP_ct_OpenPGP_unconfirmed);
  16.106 +    cout << "Recip's trust DB comm_type (should be unknown - there's nothing in the DB) = " << hex << tl_ct_string(recip1->comm_type) << endl;
  16.107 +    assert(recip1->comm_type == PEP_ct_unknown);
  16.108  
  16.109      free_message(encrypted_outgoing_msg);
  16.110      free_message(decrypted_msg);
    17.1 --- a/test/identity_list_test.cc	Wed Jan 17 11:16:22 2018 +0100
    17.2 +++ b/test/identity_list_test.cc	Thu Jan 18 00:46:19 2018 +0100
    17.3 @@ -20,6 +20,7 @@
    17.4      PEP_comm_type comm_type;    // type of communication with this ID
    17.5      char lang[3];               // language of conversation
    17.6                                  // ISO 639-1 ALPHA-2, last byte is 0
    17.7 +-    bool me;                    // if this is the local user herself/himself
    17.8      */
    17.9  
   17.10  int test_identity_equals(pEp_identity* val1, pEp_identity* val2) {
   17.11 @@ -34,7 +35,7 @@
   17.12      return((strcmp(val1->address, val2->address) == 0) && (strcmp(val1->fpr, val2->fpr) == 0)
   17.13          && (strcmp(val1->username, val2->username) == 0) && (val1->comm_type == val2->comm_type)
   17.14          && (val1->lang[0] == val2->lang[0]) && (val1->lang[1] == val2->lang[1])
   17.15 -        && (val1->lang[2] == val2->lang[2]));
   17.16 +        && (val1->lang[2] == val2->lang[2]) && (val1->me == val2->me));
   17.17  }
   17.18  
   17.19  int main() {
    18.1 --- a/test/least_color_group_test.cc	Wed Jan 17 11:16:22 2018 +0100
    18.2 +++ b/test/least_color_group_test.cc	Thu Jan 18 00:46:19 2018 +0100
    18.3 @@ -46,9 +46,8 @@
    18.4      pEp_identity * me1 = new_identity("pep.color.test.P@kgrothoff.org", 
    18.5                                        "7EE6C60C68851954E1797F81EA59715E3EBE215C", 
    18.6                                        PEP_OWN_USERID, "Pep Color Test P (recip)");
    18.7 +    me1->me = true;
    18.8      PEP_STATUS status = update_identity(session, me1);
    18.9 -    trust_personal_key(session, me1);
   18.10 -    status = update_identity(session, me1);
   18.11      
   18.12      pEp_identity * sender1 = new_identity("pep.color.test.V@kgrothoff.org",
   18.13                                            NULL, "TOFU_pep.color.test.V@kgrothoff.org",
    19.1 --- a/test/least_common_denom_color_test.cc	Wed Jan 17 11:16:22 2018 +0100
    19.2 +++ b/test/least_common_denom_color_test.cc	Thu Jan 18 00:46:19 2018 +0100
    19.3 @@ -36,14 +36,17 @@
    19.4      PEP_STATUS statuskey4 = import_key(session, keytextkey4.c_str(), keytextkey4.length(), NULL);
    19.5  
    19.6      pEp_identity * sender = new_identity("pep.never.me.test@kgrothoff.org", NULL, "TOFU_pep.never.me.test@kgrothoff.org", "pEp Never Me Test");    
    19.7 +    sender->me = false;    
    19.8      PEP_STATUS status = update_identity(session, sender);
    19.9          
   19.10      // reset the trust on both keys before we start
   19.11      pEp_identity * recip1 = new_identity("banmeonce@kgrothoff.org", NULL, "TOFU_banemeonce@kgrothoff.org", "Ban Me Once");    
   19.12 +    recip1->me = false;    
   19.13      status = update_identity(session, recip1);
   19.14      key_reset_trust(session, recip1);
   19.15      
   19.16      pEp_identity * recip2 = new_identity("banmetwice@kgrothoff.org", NULL, "TOFU_banemetwice@kgrothoff.org", "Ban Me Twice");    
   19.17 +    recip2->me = false;    
   19.18      status = update_identity(session, recip2);
   19.19      key_reset_trust(session, recip2);
   19.20          
    20.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    20.2 +++ b/test/message_2.0_test.cc	Thu Jan 18 00:46:19 2018 +0100
    20.3 @@ -0,0 +1,168 @@
    20.4 +// This file is under GNU General Public License 3.0
    20.5 +// see LICENSE.txt
    20.6 +
    20.7 +#include <stdlib.h>
    20.8 +#include <string.h>
    20.9 +#include "platform.h"
   20.10 +#include <iostream>
   20.11 +#include <fstream>
   20.12 +#include <assert.h>
   20.13 +#include "mime.h"
   20.14 +#include "message_api.h"
   20.15 +#include "keymanagement.h"
   20.16 +#include "test_util.h"
   20.17 +
   20.18 +using namespace std;
   20.19 +
   20.20 +int main() {
   20.21 +    cout << "\n*** message_2.0_test ***\n\n";
   20.22 +
   20.23 +    PEP_SESSION session;
   20.24 +    
   20.25 +    cout << "calling init()\n";
   20.26 +    PEP_STATUS status1 = init(&session);
   20.27 +    assert(status1 == PEP_STATUS_OK);
   20.28 +    assert(session);
   20.29 +    cout << "init() completed.\n";
   20.30 +
   20.31 +    PEP_comm_type carol_comm_type = PEP_ct_OpenPGP_unconfirmed;
   20.32 +
   20.33 +    // message_api test code
   20.34 +
   20.35 +    const string alice_pub_key = slurp("test_keys/pub/pep-test-alice-0x6FF00E97_pub.asc");
   20.36 +    const string alice_priv_key = slurp("test_keys/priv/pep-test-alice-0x6FF00E97_priv.asc");
   20.37 +    const string carol_pub_key = slurp("test_keys/pub/pep-test-carol-0x42A85A42_pub.asc");
   20.38 +    const string carol_priv_key = slurp("test_keys/priv/pep-test-carol-0x42A85A42_priv.asc");
   20.39 +
   20.40 +    PEP_STATUS statuspub = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL);
   20.41 +    PEP_STATUS statuspriv = import_key(session, alice_priv_key.c_str(), alice_priv_key.length(), NULL);
   20.42 +    assert(statuspub == PEP_STATUS_OK);
   20.43 +    assert(statuspriv == PEP_STATUS_OK);
   20.44 +    statuspub = import_key(session, carol_pub_key.c_str(), carol_pub_key.length(), NULL);
   20.45 +    statuspriv = import_key(session, carol_priv_key.c_str(), carol_priv_key.length(), NULL);
   20.46 +    assert(statuspub == PEP_STATUS_OK);
   20.47 +    assert(statuspriv == PEP_STATUS_OK);
   20.48 +
   20.49 +    cout << "creating message…\n";
   20.50 +    pEp_identity* alice = new_identity("pep.test.alice@pep-project.org", "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97", PEP_OWN_USERID, "Alice Test");
   20.51 +    pEp_identity* carol = new_identity("pep-test-carol@pep-project.org", NULL, "TOFU_pep-test-carol@pep-project.org", "Carol Test");
   20.52 +
   20.53 +    PEP_STATUS alice_status = update_identity(session, alice);
   20.54 +    PEP_STATUS carol_status = update_identity(session, carol);
   20.55 +
   20.56 +    PEP_STATUS status = update_trust_for_fpr(session, alice->fpr, PEP_ct_pEp);
   20.57 +    status = update_trust_for_fpr(session, carol->fpr, carol_comm_type);
   20.58 +    
   20.59 +    PEP_STATUS mystatus = myself(session, alice);
   20.60 +    assert(mystatus == PEP_STATUS_OK);
   20.61 +    alice_status = update_identity(session, alice);
   20.62 +    alice_status = update_identity(session, carol);
   20.63 +    assert(alice->comm_type == PEP_ct_pEp);
   20.64 +    assert(carol->comm_type == carol_comm_type);
   20.65 +    
   20.66 +    identity_list* to_list = new_identity_list(carol); // to carol
   20.67 +    message* outgoing_message = new_message(PEP_dir_outgoing);
   20.68 +    assert(outgoing_message);
   20.69 +    outgoing_message->from = alice;
   20.70 +    outgoing_message->to = to_list;
   20.71 +    outgoing_message->shortmsg = strdup("Greetings, humans!");
   20.72 +    outgoing_message->longmsg = strdup("This is a test of the emergency message system. This is only a test. BEEP.");
   20.73 +    outgoing_message->attachments = new_bloblist(NULL, 0, "application/octet-stream", NULL);
   20.74 +//    outgoing_message->id = strdup("blahblahyourmama@pep-project.org");
   20.75 +    outgoing_message->references = new_stringlist("one-839274982347239847@pep-project.org");
   20.76 +    stringlist_add(outgoing_message->references, "two-dfddffd839274982347239847@pep-project.org");
   20.77 +    stringlist_add(outgoing_message->references, "three-OMGWTFBBQ.edfddffd839274982347239847@pep-project.org");
   20.78 +    
   20.79 +    cout << "message created.\n";
   20.80 +
   20.81 +    char* encoded_text = nullptr;
   20.82 +    status = mime_encode_message(outgoing_message, false, &encoded_text);
   20.83 +    assert(status == PEP_STATUS_OK);
   20.84 +    assert(encoded_text);
   20.85 +
   20.86 +    cout << "unencrypted:\n\n";
   20.87 +    cout << encoded_text << "\n";
   20.88 +
   20.89 +    free(encoded_text);
   20.90 +
   20.91 +    cout << "encrypting message as MIME multipart…\n";
   20.92 +    message* encrypted_msg = nullptr;
   20.93 +    cout << "calling encrypt_message\n";
   20.94 +    status = encrypt_message(session, outgoing_message, NULL, 
   20.95 +        &encrypted_msg, PEP_enc_PGP_MIME, 0);
   20.96 +    cout << "encrypt_message() returns " << std::hex << status << '.' << endl;
   20.97 +    assert(status == PEP_STATUS_OK);
   20.98 +    assert(encrypted_msg);
   20.99 +    cout << "message encrypted.\n";
  20.100 +    
  20.101 +    encrypted_msg->enc_format = PEP_enc_none;
  20.102 +    status = mime_encode_message(encrypted_msg, false, &encoded_text);
  20.103 +    assert(status == PEP_STATUS_OK);
  20.104 +    assert(encoded_text);
  20.105 +     
  20.106 +    cout << "encrypted:\n\n";
  20.107 +    cout << encoded_text << "\n";
  20.108 +     
  20.109 +    char* decrypted_text;
  20.110 +    
  20.111 +    message* decrypted_msg = nullptr;
  20.112 +    stringlist_t* keylist_used = nullptr;
  20.113 +    
  20.114 +    PEP_rating rating;
  20.115 +    PEP_decrypt_flags_t flags;
  20.116 +     
  20.117 +//    MIME_decrypt_message(session, encoded_text, strlen(encoded_text), &decrypted_text, &keylist_used, &rating, &flags);
  20.118 +    
  20.119 +//    cout << "HEY!" << endl;
  20.120 +//    cout << decrypted_text << endl;
  20.121 +    
  20.122 +    message* decoded_msg = nullptr;
  20.123 +    status = mime_decode_message(encoded_text, strlen(encoded_text), &decoded_msg);
  20.124 +    assert(status == PEP_STATUS_OK);
  20.125 +    const string string3 = encoded_text;
  20.126 +      
  20.127 +    unlink("msg_2.0.asc");
  20.128 +    ofstream outFile3("msg_2.0.asc");
  20.129 +    outFile3.write(string3.c_str(), string3.size());
  20.130 +    outFile3.close();
  20.131 +    
  20.132 +    // message* decrypted_msg = nullptr;
  20.133 +    // stringlist_t* keylist_used = nullptr;
  20.134 +    // 
  20.135 +    // PEP_rating rating;
  20.136 +    // PEP_decrypt_flags_t flags;
  20.137 +    // 
  20.138 +    stringpair_t* autoconsume = new_stringpair("pEp-auto-consume", "yes");
  20.139 +    stringpair_list_add(encrypted_msg->opt_fields, autoconsume);
  20.140 +    status = decrypt_message(session, encrypted_msg, &decrypted_msg, &keylist_used, &rating, &flags);
  20.141 +    assert(decrypted_msg);
  20.142 +    assert(keylist_used);
  20.143 +    assert(rating);
  20.144 +    //assert(status == PEP_STATUS_OK && rating == PEP_rating_reliable);
  20.145 +    //PEP_comm_type ct = encrypted_msg->from->comm_type;
  20.146 +    //assert(ct == PEP_ct_pEp);
  20.147 +    
  20.148 +    cout << "keys used:\n";
  20.149 +    
  20.150 +    for (stringlist_t* kl4 = keylist_used; kl4 && kl4->value; kl4 = kl4->next)
  20.151 +    {
  20.152 +       cout << "\t " << kl4->value << endl;
  20.153 +    }
  20.154 +     
  20.155 +    decrypted_msg->enc_format = PEP_enc_none; 
  20.156 +    status = _mime_encode_message_internal(decrypted_msg, false, &encoded_text, false);
  20.157 +    assert(status == PEP_STATUS_OK);
  20.158 +    assert(encoded_text);
  20.159 +    cout << "Decrypted message: " << endl;
  20.160 +    cout << encoded_text << endl;
  20.161 +     
  20.162 +    cout << "freeing messages…\n";
  20.163 +    free_message(encrypted_msg);
  20.164 +    free_message(decrypted_msg);
  20.165 +    free_message(outgoing_message);
  20.166 +    cout << "done.\n";
  20.167 +    
  20.168 +    cout << "calling release()\n";
  20.169 +    release(session);
  20.170 +    return 0;
  20.171 +}
    21.1 --- a/test/message_api_test.cc	Wed Jan 17 11:16:22 2018 +0100
    21.2 +++ b/test/message_api_test.cc	Thu Jan 18 00:46:19 2018 +0100
    21.3 @@ -147,6 +147,7 @@
    21.4  	
    21.5  	std::cout << "MIME_decrypt_message returned " << std::dec << status2 << std::hex << " (0x" << status2 << ")" << std::dec << endl;
    21.6  	
    21.7 +    // We have no public key, so we cannot, in fact, VERIFY the message. SO cannot be PEP_STATUS_OK.
    21.8  	assert(status2 == PEP_DECRYPTED);
    21.9  	assert(plaintext);
   21.10  	
   21.11 @@ -162,7 +163,6 @@
   21.12  	free_identity_list(pk);
   21.13  }
   21.14  
   21.15 -
   21.16  int main() {
   21.17      cout << "\n*** message_api_test ***\n\n";
   21.18      test_MIME_decrypt_message();
   21.19 @@ -180,6 +180,7 @@
   21.20      cout << "creating message…\n";
   21.21      pEp_identity * me2 = new_identity("pep.test.alice@pep-project.org", NULL, PEP_OWN_USERID, "Alice Test");
   21.22      // pEp_identity * me2 = new_identity("test@nokey.plop", NULL, PEP_OWN_USERID, "Test no key");
   21.23 +    me2->me = true;
   21.24      identity_list *to2 = new_identity_list(new_identity("pep.test.bob@pep-project.org", NULL, "42", "Bob Test"));
   21.25      // identity_list *to2 = new_identity_list(new_identity("still@nokey.blup", NULL, "42", "Still no key"));
   21.26      message *msg2 = new_message(PEP_dir_outgoing);
    22.1 --- a/test/mistrust_undo_test.cc	Wed Jan 17 11:16:22 2018 +0100
    22.2 +++ b/test/mistrust_undo_test.cc	Thu Jan 18 00:46:19 2018 +0100
    22.3 @@ -40,8 +40,12 @@
    22.4      assert(status == PEP_STATUS_OK);
    22.5      assert(strcmp(recip1->fpr, "BACC7A60A88A39A25D99B4A545D7542F39E5DAB5") == 0);
    22.6      
    22.7 +    // First, we need the fpr to be in the DB system.
    22.8 +    status = set_identity(session,recip1);
    22.9 +    // Then we update the trust.
   22.10      // This is not an external function. We use it to expedite the test since we don't do a sync exchange here.
   22.11      status = update_trust_for_fpr(session, recip1->fpr, PEP_ct_pEp);
   22.12 +    // Then we retrieve the new trust.
   22.13      status = update_identity(session,recip1);
   22.14      assert(status == PEP_STATUS_OK);
   22.15      assert(recip1->comm_type == PEP_ct_pEp);
    23.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    23.2 +++ b/test/new_update_id_and_myself_test.cc	Thu Jan 18 00:46:19 2018 +0100
    23.3 @@ -0,0 +1,512 @@
    23.4 +// This file is under GNU General Public License 3.0
    23.5 +// see LICENSE.txt
    23.6 +
    23.7 +#include <iostream>
    23.8 +#include <iostream>
    23.9 +#include <fstream>
   23.10 +#include <string>
   23.11 +#include <cstring> // for strcmp()
   23.12 +#include <assert.h>
   23.13 +#include "pEpEngine.h"
   23.14 +#include "message_api.h"
   23.15 +#include "keymanagement.h"
   23.16 +#include "test_util.h"
   23.17 +
   23.18 +using namespace std;
   23.19 +
   23.20 +int main() {
   23.21 +    cout << "\n*** test update_identity and myself ***\n\n";
   23.22 +    
   23.23 +    PEP_SESSION session;
   23.24 +    
   23.25 +    cout << "calling init()\n";
   23.26 +    PEP_STATUS status = init(&session);
   23.27 +    assert(status == PEP_STATUS_OK);
   23.28 +    assert(session);
   23.29 +    cout << "init() completed.\n";
   23.30 +    cout << endl;
   23.31 +    cout << "***********************************************************************" << endl;
   23.32 +    cout << "* Section I. myself()" << endl;
   23.33 +    cout << "***********************************************************************" << endl << endl;
   23.34 +
   23.35 +    // Create id with no key
   23.36 +    cout << "Creating new own id with no key for : ";
   23.37 +    char *uniqname = strdup("AAAAtestuser@testdomain.org");
   23.38 +    srandom(time(NULL));
   23.39 +    for(int i=0; i < 4;i++)
   23.40 +        uniqname[i] += random() & 0xf;
   23.41 +    
   23.42 +    cout << uniqname << "\n";
   23.43 +    
   23.44 +    const char* own_user_id = "FineOwnIdentitiesOfBuckTFerris";
   23.45 +    const char* start_username = "Unser Testkandidat";
   23.46 +
   23.47 +    pEp_identity * new_me = new_identity(uniqname, NULL, own_user_id, start_username);
   23.48 +    
   23.49 +    cout << "***********************************************************************" << endl;
   23.50 +    cout << "* I: 1. myself() on id with no record in the DB and no input fpr" << endl;
   23.51 +    cout << "***********************************************************************" << endl << endl;
   23.52 +    status = myself(session, new_me);
   23.53 +    assert(status == PEP_STATUS_OK);
   23.54 +    assert(new_me->fpr);
   23.55 +    
   23.56 +    cout << "PASS: myself() generated fingerprint ";
   23.57 +    cout << new_me->fpr << endl << endl;
   23.58 +
   23.59 +    char* generated_fpr = strdup(new_me->fpr);
   23.60 +    
   23.61 +    assert(new_me->comm_type == PEP_ct_pEp);
   23.62 +    
   23.63 +    free_identity(new_me);
   23.64 +
   23.65 +    cout << "***********************************************************************" << endl;
   23.66 +    cout << "* I: 2. myself() on id with no input fpr and a record in the DB" << endl;
   23.67 +    cout << "***********************************************************************" << endl << endl;
   23.68 +
   23.69 +    new_me = new_identity(uniqname, NULL, own_user_id, NULL);
   23.70 +    status = myself(session, new_me);
   23.71 +    assert(status == PEP_STATUS_OK);
   23.72 +    
   23.73 +    assert(new_me->fpr);
   23.74 +    assert(strcmp(new_me->fpr, generated_fpr) == 0);
   23.75 +    assert(new_me->username);
   23.76 +    assert(strcmp(new_me->username, start_username) == 0);
   23.77 +    assert(new_me->user_id);
   23.78 +    assert(new_me->comm_type == PEP_ct_pEp);
   23.79 +    
   23.80 +    char* default_own_id = NULL;
   23.81 +    status = get_userid_alias_default(session, own_user_id, &default_own_id);
   23.82 +    if (status == PEP_CANNOT_FIND_ALIAS) {
   23.83 +        // Ok, we presume our own id above is the default (should be true if there was no existing DB as in test env)
   23.84 +        default_own_id = strdup(own_user_id);
   23.85 +    }
   23.86 +
   23.87 +    assert(strcmp(new_me->user_id, default_own_id) == 0);
   23.88 +    
   23.89 +    cout << "PASS: myself() retrieved the correct fpr, username and default user id" << endl << endl;
   23.90 +
   23.91 +    free_identity(new_me);
   23.92 +     
   23.93 +    cout << "****************************************************************************************" << endl;
   23.94 +    cout << "* I: 3. myself() on id with no input fpr, a different user_id, and a record in the DB" << endl;
   23.95 +    cout << "****************************************************************************************" << endl << endl;
   23.96 +
   23.97 +    const char* alias_id = "Huss Es El Mejor Presidente Del Mundo!";
   23.98 +
   23.99 +    new_me = new_identity(uniqname, NULL, alias_id, NULL);
  23.100 +    status = myself(session, new_me);
  23.101 +    assert(status == PEP_STATUS_OK);
  23.102 +    
  23.103 +    assert(new_me->fpr);
  23.104 +    assert(strcmp(new_me->fpr, generated_fpr) == 0);
  23.105 +    assert(new_me->username);
  23.106 +    assert(strcmp(new_me->username, start_username) == 0);
  23.107 +    assert(new_me->user_id);
  23.108 +    assert(strcmp(new_me->user_id, default_own_id) == 0);
  23.109 +    assert(new_me->comm_type == PEP_ct_pEp);
  23.110 +    
  23.111 +    char* tmp_def = NULL;
  23.112 +    
  23.113 +    status = get_userid_alias_default(session, alias_id, &tmp_def);
  23.114 +    assert(status == PEP_STATUS_OK);
  23.115 +    assert(strcmp(tmp_def, default_own_id) == 0);
  23.116 +
  23.117 +    cout << "PASS: myself() retrieved the correct fpr, username and default user id, and put the right alias in for the default";
  23.118 +    cout << endl << endl;
  23.119 +    
  23.120 +    free(tmp_def);
  23.121 +    free_identity(new_me);
  23.122 +
  23.123 +    cout << "****************************************************************************************" << endl;
  23.124 +    cout << "* I: 4. myself(), replace fpr" << endl;
  23.125 +    cout << "****************************************************************************************" << endl << endl;
  23.126 +
  23.127 +    new_me = new_identity(uniqname, NULL, alias_id, start_username);
  23.128 +    status = generate_keypair(session, new_me);
  23.129 +    assert(new_me->fpr);
  23.130 +    
  23.131 +    cout << "Generated fingerprint ";
  23.132 +    cout << new_me->fpr << "\n";
  23.133 +
  23.134 +    char* new_fpr = strdup(new_me->fpr);
  23.135 +
  23.136 +    new_me = new_identity(uniqname, new_fpr, alias_id, NULL);
  23.137 +
  23.138 +    status = myself(session, new_me);
  23.139 +    assert(status == PEP_STATUS_OK);
  23.140 +    assert(new_me->fpr);
  23.141 +    assert(strcmp(new_me->fpr, generated_fpr) != 0);
  23.142 +    assert(strcmp(new_me->fpr, new_fpr) == 0);
  23.143 +    assert(new_me->username);
  23.144 +    assert(strcmp(new_me->username, start_username) == 0);
  23.145 +    assert(new_me->user_id);
  23.146 +    assert(strcmp(new_me->user_id, default_own_id) == 0);
  23.147 +    assert(new_me->me);
  23.148 +    assert(new_me->comm_type == PEP_ct_pEp);
  23.149 +
  23.150 +    cout << "PASS: myself() set and retrieved the new fpr, username and default user id, and put the right alias in for the default";
  23.151 +    cout << endl << endl;
  23.152 +
  23.153 +    // since that worked, we'll set it back as the default
  23.154 +    free(new_me->fpr);
  23.155 +    new_me->fpr = strdup(generated_fpr);
  23.156 +    new_me->comm_type = PEP_ct_unknown;
  23.157 +    status = myself(session, new_me);
  23.158 +    assert(status == PEP_STATUS_OK);
  23.159 +    assert(strcmp(new_me->fpr, generated_fpr) == 0);
  23.160 +    assert(new_me->comm_type == PEP_ct_pEp);
  23.161 +    
  23.162 +    cout << "****************************************************************************************" << endl;
  23.163 +    cout << "* I: 5. myself(), replace fpr, revoke key" << endl;
  23.164 +    cout << "****************************************************************************************" << endl << endl;
  23.165 +
  23.166 +    status = revoke_key(session, generated_fpr, "Because it's fun");
  23.167 +    assert (status == PEP_STATUS_OK);
  23.168 +    
  23.169 +    new_me = new_identity(uniqname, new_fpr, alias_id, NULL);
  23.170 +    
  23.171 +    status = myself(session, new_me);
  23.172 +    assert(status == PEP_STATUS_OK);
  23.173 +    assert(new_me->fpr);
  23.174 +    assert(strcmp(new_me->fpr, generated_fpr) != 0);
  23.175 +    assert(new_me->username);
  23.176 +    assert(strcmp(new_me->username, start_username) == 0);
  23.177 +    assert(new_me->user_id);
  23.178 +    assert(strcmp(new_me->user_id, default_own_id) == 0);
  23.179 +    assert(new_me->me);
  23.180 +    assert(new_me->comm_type == PEP_ct_pEp);
  23.181 +    
  23.182 +    cout << "PASS: myself() retrieved the new fpr, username and default user id, and put the right alias in for the default";
  23.183 +    cout << endl << endl;
  23.184 +        
  23.185 +    cout << "***********************************************************************" << endl;
  23.186 +    cout << "* Section II. update_identity()" << endl;
  23.187 +    cout << "***********************************************************************" << endl << endl;
  23.188 +
  23.189 +    cout << "****************************************************************************************" << endl;
  23.190 +    cout << "* II: 1. update_identity() - get identity with matching address and user_id and username" << endl;
  23.191 +    cout << "****************************************************************************************" << endl << endl;    
  23.192 +    // 1. create original identity
  23.193 +    const char* alex_address = "pep.test.alexander@peptest.ch";
  23.194 +    const char* alex_fpr = "3AD9F60FAEB22675DB873A1362D6981326B54E4E";
  23.195 +    const char* alex_userid = "Alex";
  23.196 +    const char* alex_username = "SuperDuperAlex";
  23.197 +    const string alex_pub_key = slurp("test_keys/pub/pep.test.alexander-0x26B54E4E_pub.asc");
  23.198 +    
  23.199 +    PEP_STATUS statuspub = import_key(session, alex_pub_key.c_str(), alex_pub_key.length(), NULL);
  23.200 +    assert(statuspub == PEP_STATUS_OK);
  23.201 +
  23.202 +    pEp_identity* alex = new_identity(alex_address, alex_fpr, alex_userid, alex_username);
  23.203 +
  23.204 +    // 2. set identity
  23.205 +    status = set_identity(session, alex);
  23.206 +    assert(status == PEP_STATUS_OK);
  23.207 +    free_identity(alex);
  23.208 +            
  23.209 +    alex = new_identity(alex_address, NULL, alex_userid, alex_username); 
  23.210 +    status = update_identity(session, alex);
  23.211 +    assert(status == PEP_STATUS_OK);
  23.212 +    assert(alex->fpr);
  23.213 +    assert(strcmp(alex->fpr, alex_fpr) == 0);
  23.214 +    assert(alex->username);
  23.215 +    assert(strcmp(alex->username, alex_username) == 0);
  23.216 +    assert(alex->user_id);
  23.217 +    assert(strcmp(alex->user_id, alex_userid) == 0);
  23.218 +    assert(!alex->me); 
  23.219 +    assert(alex->comm_type == PEP_ct_OpenPGP_unconfirmed);
  23.220 +    assert(strcmp(alex->address, alex_address) == 0);
  23.221 +
  23.222 +    cout << "PASS: update_identity() correctly retrieved extant record with matching address, id, and username" << endl << endl;
  23.223 +    free_identity(alex);
  23.224 +
  23.225 +    cout << "****************************************************************************************" << endl;
  23.226 +    cout << "* II: 2. update_identity() - get identity with matching address and user_id and new username" << endl;
  23.227 +    cout << "****************************************************************************************" << endl << endl;    
  23.228 +
  23.229 +    const char* new_username = "Test Patchy";
  23.230 +            
  23.231 +    alex = new_identity(alex_address, NULL, alex_userid, new_username); 
  23.232 +    status = update_identity(session, alex);
  23.233 +    assert(status == PEP_STATUS_OK);
  23.234 +    assert(alex->fpr);
  23.235 +    assert(strcmp(alex->fpr, alex_fpr) == 0);
  23.236 +    assert(alex->username);
  23.237 +    assert(strcmp(alex->username, new_username) == 0);
  23.238 +    assert(alex->user_id);
  23.239 +    assert(strcmp(alex->user_id, alex_userid) == 0);
  23.240 +    assert(!alex->me); 
  23.241 +    assert(alex->comm_type == PEP_ct_OpenPGP_unconfirmed);
  23.242 +    assert(strcmp(alex->address, alex_address) == 0);
  23.243 +
  23.244 +    cout << "PASS: update_identity() correctly retrieved extant record with matching address and id, and patched username" << endl << endl;
  23.245 +    free_identity(alex);
  23.246 +
  23.247 +    cout << "****************************************************************************************" << endl;
  23.248 +    cout << "* II: 3. update_identity() - get identity with matching address and user_id only" << endl;
  23.249 +    cout << "****************************************************************************************" << endl << endl;    
  23.250 +        
  23.251 +    alex = new_identity(alex_address, NULL, alex_userid, NULL); 
  23.252 +    status = update_identity(session, alex);
  23.253 +    assert(status == PEP_STATUS_OK);
  23.254 +    assert(alex->fpr);
  23.255 +    assert(strcmp(alex->fpr, alex_fpr) == 0);
  23.256 +    assert(alex->username);
  23.257 +    assert(strcmp(alex->username, new_username) == 0);
  23.258 +    assert(alex->user_id);
  23.259 +    assert(strcmp(alex->user_id, alex_userid) == 0);
  23.260 +    assert(!alex->me); 
  23.261 +    assert(alex->comm_type == PEP_ct_OpenPGP_unconfirmed);
  23.262 +    assert(strcmp(alex->address, alex_address) == 0);
  23.263 +
  23.264 +    cout << "PASS: update_identity() correctly retrieved extant record with matching address and id, and patched username" << endl << endl;
  23.265 +    free_identity(alex);
  23.266 +
  23.267 +    cout << "****************************************************************************************" << endl;
  23.268 +    cout << "* II: 4. update_identity() - get identity with just address and username" << endl;
  23.269 +    cout << "****************************************************************************************" << endl << endl;    
  23.270 +
  23.271 +    alex = new_identity(alex_address, NULL, NULL, new_username); 
  23.272 +    status = update_identity(session, alex);
  23.273 +    assert(status == PEP_STATUS_OK);
  23.274 +    assert(alex->fpr);
  23.275 +    assert(strcmp(alex->fpr, alex_fpr) == 0);
  23.276 +    assert(alex->username);
  23.277 +    assert(strcmp(alex->username, new_username) == 0);
  23.278 +    assert(alex->user_id);
  23.279 +    assert(strcmp(alex->user_id, alex_userid) == 0);
  23.280 +    assert(!alex->me); 
  23.281 +    assert(alex->comm_type == PEP_ct_OpenPGP_unconfirmed);
  23.282 +    assert(strcmp(alex->address, alex_address) == 0);
  23.283 +
  23.284 +    cout << "PASS: update_identity() correctly retrieved extant record with matching address and username" << endl << endl;
  23.285 +    free_identity(alex);
  23.286 +
  23.287 +    cout << "****************************************************************************************" << endl;
  23.288 +    cout << "* II: 5. update_identity() with just address " << endl;
  23.289 +    cout << "****************************************************************************************" << endl << endl;
  23.290 +    
  23.291 +    alex = new_identity(alex_address, NULL, NULL, NULL); 
  23.292 +    status = update_identity(session, alex);
  23.293 +    assert(status == PEP_STATUS_OK);
  23.294 +    assert(alex->fpr);
  23.295 +    assert(strcmp(alex->fpr, alex_fpr) == 0);
  23.296 +    assert(alex->username);
  23.297 +    assert(strcmp(alex->username, new_username) == 0);
  23.298 +    assert(alex->user_id);
  23.299 +    assert(strcmp(alex->user_id, alex_userid) == 0);
  23.300 +    assert(!alex->me); 
  23.301 +    assert(alex->comm_type == PEP_ct_OpenPGP_unconfirmed);
  23.302 +    assert(strcmp(alex->address, alex_address) == 0);
  23.303 +
  23.304 +    cout << "PASS: update_identity() correctly retrieved extant record with just matching address. Retrieved previously patched username." << endl << endl;
  23.305 +    free_identity(alex);
  23.306 +
  23.307 +
  23.308 +    cout << "****************************************************************************************" << endl;
  23.309 +    cout << "* II: 6. update_identity() with just address on own identity (only case where this is legal)" << endl;
  23.310 +    cout << "****************************************************************************************" << endl << endl;
  23.311 +    
  23.312 +    pEp_identity* somebody = new_identity(uniqname, NULL, NULL, NULL); 
  23.313 +    status = update_identity(session, somebody);
  23.314 +    assert(status == PEP_STATUS_OK);
  23.315 +    myself(session, somebody);
  23.316 +    assert(somebody->fpr);
  23.317 +    assert(strcmp(somebody->fpr, new_fpr) == 0);
  23.318 +    assert(somebody->username);
  23.319 +    assert(strcmp(somebody->username, start_username) == 0);
  23.320 +    assert(somebody->user_id);
  23.321 +    assert(strcmp(somebody->user_id, default_own_id) == 0);
  23.322 +    assert(somebody->me); // true in this case, as it was an own identity
  23.323 +    assert(somebody->comm_type == PEP_ct_pEp);
  23.324 +    assert(strcmp(somebody->address, uniqname) == 0);
  23.325 +    
  23.326 +    cout << "PASS: update_identity() retrieved the right identity information given just an address";
  23.327 +    cout << endl << endl;
  23.328 +
  23.329 +    free_identity(somebody);
  23.330 +
  23.331 +    cout << "****************************************************************************************" << endl;
  23.332 +    cout << "* II: 7. update_identity() for address and user_id that don't exist" << endl;
  23.333 +    cout << "****************************************************************************************" << endl << endl;
  23.334 +
  23.335 +    somebody = new_identity("nope@nope.nope", NULL, "some_user_id", NULL); 
  23.336 +    status = update_identity(session, somebody);
  23.337 +    assert(status == PEP_CANNOT_FIND_IDENTITY);
  23.338 +    cout << "PASS: update_identity() returns PEP_CANNOT_FIND_IDENTITY" << endl << endl;
  23.339 +
  23.340 +    free_identity(somebody);
  23.341 +    
  23.342 +    cout << "****************************************************************************************" << endl;
  23.343 +    cout << "* II: 8. update_identity() for address and and username, but non-matching temp user_id" << endl;
  23.344 +    cout << "****************************************************************************************" << endl << endl;
  23.345 +
  23.346 +    // 1. create identity
  23.347 +    const char* bella_address = "pep.test.bella@peptest.ch";
  23.348 +    const char* bella_fpr = "5631BF1357326A02AA470EEEB815EF7FA4516AAE";
  23.349 +    const char* bella_userid = "TOFU_pep.test.bella@peptest.ch"; // simulate temp ID
  23.350 +    const char* bella_username = "Annabella the Great";
  23.351 +    const string bella_pub_key = slurp("test_keys/pub/pep.test.bella-0xAF516AAE_pub.asc");
  23.352 +    
  23.353 +    statuspub = import_key(session, bella_pub_key.c_str(), bella_pub_key.length(), NULL);
  23.354 +    assert(statuspub == PEP_STATUS_OK);
  23.355 +
  23.356 +    pEp_identity* bella = new_identity(bella_address, bella_fpr, bella_userid, bella_username);
  23.357 +    
  23.358 +    // 2. set identity
  23.359 +    status = set_identity(session, bella);
  23.360 +    assert(status == PEP_STATUS_OK);
  23.361 +    free_identity(bella);
  23.362 +    
  23.363 +    const char* not_my_userid = "Bad Company";
  23.364 +            
  23.365 +    bella = new_identity(bella_address, NULL, not_my_userid, bella_username); 
  23.366 +    status = update_identity(session, bella);
  23.367 +    assert(status == PEP_STATUS_OK);
  23.368 +    assert(bella->fpr);
  23.369 +    assert(strcmp(bella->fpr, bella_fpr) == 0);
  23.370 +    assert(bella->username);
  23.371 +    assert(strcmp(bella->username, bella_username) == 0);
  23.372 +    assert(bella->user_id);
  23.373 +    assert(strcmp(bella->user_id, not_my_userid) == 0); // ???
  23.374 +    assert(!bella->me); 
  23.375 +    assert(bella->comm_type == PEP_ct_OpenPGP_unconfirmed);
  23.376 +    assert(strcmp(bella->address, bella_address) == 0);
  23.377 +
  23.378 +    cout << "PASS: update_identity() correctly retrieved extant record with matching address and username; temp user_id in DB patched" << endl << endl;
  23.379 +    free_identity(bella);
  23.380 +
  23.381 +    cout << "****************************************************************************************" << endl;
  23.382 +    cout << "* II: 9. update_identity() for address, username, and user_id, but no matching record" << endl;
  23.383 +    cout << "****************************************************************************************" << endl << endl;
  23.384 +    
  23.385 +    const char* rando_name = "Pickley BoofBoof";
  23.386 +    const char* rando_userid = "Boofy";
  23.387 +    const char* rando_address = "boof@pickles.org";
  23.388 +    somebody = new_identity(rando_address, NULL, rando_userid, rando_name);
  23.389 +    status = update_identity(session, somebody);
  23.390 +
  23.391 +    assert(status == PEP_STATUS_OK);
  23.392 +    assert(!somebody->fpr || somebody->fpr[0] == '\0');
  23.393 +    assert(somebody->username);
  23.394 +    assert(strcmp(somebody->username, rando_name) == 0);
  23.395 +    assert(somebody->user_id);
  23.396 +    assert(strcmp(somebody->user_id, rando_userid) == 0); // ???
  23.397 +    assert(!somebody->me); 
  23.398 +    assert(somebody->comm_type == PEP_ct_key_not_found);
  23.399 +    assert(strcmp(somebody->address, rando_address) == 0);
  23.400 +
  23.401 +    cout << "PASS: update_identity() correctly created record with no key" << endl << endl;
  23.402 +    free_identity(somebody);
  23.403 +    
  23.404 +    cout << "****************************************************************************************" << endl;
  23.405 +    cout << "* II: 10. update_identity() for address, username, but no matching record" << endl;
  23.406 +    cout << "****************************************************************************************" << endl << endl;
  23.407 +
  23.408 +    const char* rando2_name = "Pickles BoofyBoof";
  23.409 +    const char* rando2_address = "boof2@pickles.org";
  23.410 +    somebody = new_identity(rando2_address, NULL, NULL, rando2_name);
  23.411 +    status = update_identity(session, somebody);
  23.412 +    const char* expected_rando2_userid = "TOFU_boof2@pickles.org";
  23.413 +
  23.414 +    assert(status == PEP_STATUS_OK);
  23.415 +    assert(!somebody->fpr || somebody->fpr[0] == '\0');
  23.416 +    assert(somebody->username);
  23.417 +    assert(strcmp(somebody->username, rando2_name) == 0);
  23.418 +    assert(somebody->user_id);
  23.419 +    assert(strcmp(somebody->user_id, expected_rando2_userid) == 0); // ???
  23.420 +    assert(!somebody->me); 
  23.421 +    assert(somebody->comm_type == PEP_ct_key_not_found);
  23.422 +    assert(strcmp(somebody->address, rando2_address) == 0);
  23.423 +
  23.424 +    cout << "PASS: update_identity() correctly created record with no key" << endl << endl;
  23.425 +    free_identity(somebody);
  23.426 +
  23.427 +    cout << "****************************************************************************************" << endl;
  23.428 +    cout << "* II: 11. update_identity() for address only, but multiple matching records" << endl;
  23.429 +    cout << "****************************************************************************************" << endl << endl;
  23.430 +
  23.431 +    const char* bella_id_2 = "Bella2";
  23.432 +    bella = new_identity(bella_address, NULL, bella_id_2, bella_username);
  23.433 +    
  23.434 +    // 2. set identity
  23.435 +    status = set_identity(session, bella);
  23.436 +    assert(status == PEP_STATUS_OK);
  23.437 +    free_identity(bella);
  23.438 +                
  23.439 +    bella = new_identity(bella_address, NULL, NULL, NULL); 
  23.440 +    status = update_identity(session, bella);
  23.441 +    assert(status != PEP_STATUS_OK);
  23.442 +
  23.443 +    cout << "PASS: update_identity() correctly failed with no matching records (too little info)" << endl << endl;
  23.444 +    
  23.445 +    cout << "****************************************************************************************" << endl;
  23.446 +    cout << "* III: key election " << endl;
  23.447 +    cout << "****************************************************************************************" << endl << endl;
  23.448 +
  23.449 +    cout << "****************************************************************************************" << endl;
  23.450 +    cout << "* III: 1. key election: get identity for user with expired key" << endl;
  23.451 +    cout << "****************************************************************************************" << endl << endl;
  23.452 +
  23.453 +    // 1. create identity
  23.454 +    const char* bernd_address = "bernd.das.brot@darthmama.org";
  23.455 +    const char* bernd_fpr = "F8CE0F7E24EB190A2FCBFD38D4B088A7CAFAA422";
  23.456 +    const char* bernd_userid = "BERND_ID"; // simulate temp ID
  23.457 +    const char* bernd_username = "Bernd das Brot der Ultimative Testkandidat";
  23.458 +    const string bernd_pub_key = slurp("test_keys/pub/bernd.das.brot-0xCAFAA422_pub.asc");
  23.459 +    
  23.460 +    statuspub = import_key(session, bernd_pub_key.c_str(), bernd_pub_key.length(), NULL);
  23.461 +    assert(statuspub == PEP_STATUS_OK);
  23.462 +
  23.463 +    pEp_identity* bernd = new_identity(bernd_address, bernd_fpr, bernd_userid, bernd_username);
  23.464 +    
  23.465 +    // 2. set identity
  23.466 +    status = set_identity(session, bernd);
  23.467 +    assert(status == PEP_STATUS_OK);
  23.468 +    free_identity(bernd);
  23.469 +                
  23.470 +    bernd = new_identity(bernd_address, NULL, bernd_userid, bernd_username); 
  23.471 +    status = update_identity(session, bernd);
  23.472 +    assert(status != PEP_STATUS_OK);
  23.473 +    assert(!bernd->fpr || bernd->fpr[0] == '\0');
  23.474 +    assert(bernd->username);
  23.475 +    assert(strcmp(bernd->username, bernd_username) == 0);
  23.476 +    assert(bernd->user_id);
  23.477 +    assert(strcmp(bernd->user_id, bernd_userid) == 0); // ???
  23.478 +    assert(!bernd->me); 
  23.479 +    assert(bernd->comm_type == PEP_ct_key_expired);
  23.480 +    assert(strcmp(bernd->address, bernd_address) == 0);
  23.481 +
  23.482 +    cout << "PASS: update_identity() correctly rejected expired key with PEP_KEY_UNSUITABLE and PEP_ct_key_expired" << endl << endl;
  23.483 +    free_identity(bernd);
  23.484 +
  23.485 +
  23.486 +    cout << "****************************************************************************************" << endl;
  23.487 +    cout << "* III: 2. key election: get identity for user with only revoked keys " << endl;
  23.488 +    cout << "****************************************************************************************" << endl << endl;
  23.489 +    
  23.490 +    status = revoke_key(session, new_fpr, "Because it's more fun to revoke ALL of someone's keys");
  23.491 +    assert (status == PEP_STATUS_OK);
  23.492 +    
  23.493 +    new_me = new_identity(uniqname, NULL, NULL, NULL);
  23.494 +    
  23.495 +    status = update_identity(session, new_me);
  23.496 +    assert(status != PEP_STATUS_OK);
  23.497 +    assert(!new_me->fpr);
  23.498 +    assert(new_me->username);
  23.499 +    assert(strcmp(new_me->username, start_username) == 0);
  23.500 +    assert(new_me->user_id);
  23.501 +    assert(strcmp(new_me->user_id, default_own_id) == 0);
  23.502 +    assert(new_me->me);
  23.503 +    assert(new_me->comm_type == PEP_ct_key_revoked);
  23.504 +    
  23.505 +    cout << "PASS: update_identity() correctly rejected two revoked keys with PEP_KEY_UNSUITABLE and PEP_ct_key_revoked";
  23.506 +    cout << endl << endl;
  23.507 +
  23.508 +    free_identity(new_me);
  23.509 +
  23.510 +    cout << "****************************************************************************************" << endl;
  23.511 +    cout << "* III: 100000000. key election: more to come " << endl;
  23.512 +    cout << "****************************************************************************************" << endl << endl;
  23.513 +
  23.514 +    return 0;
  23.515 +}
    24.1 --- a/test/pEp_subject_received_test.cc	Wed Jan 17 11:16:22 2018 +0100
    24.2 +++ b/test/pEp_subject_received_test.cc	Thu Jan 18 00:46:19 2018 +0100
    24.3 @@ -34,10 +34,12 @@
    24.4      PEP_STATUS statuskey3 = import_key(session, keytextkey3.c_str(), keytextkey3.length(), NULL);
    24.5  
    24.6      pEp_identity * me = new_identity("pep.test.recip@kgrothoff.org", "93D19F24AD6F4C4BA9134AAF84D9217908DB0AEE", PEP_OWN_USERID, "pEp Test Recipient");    
    24.7 +    me->me = true;
    24.8      PEP_STATUS status = myself(session, me);
    24.9      
   24.10      pEp_identity * you = new_identity("pep.test.alice@pep-project.org", NULL, "TOFU_pep.test.alice@pep-project.org", "Alice Test");    
   24.11 -    
   24.12 +    you->me = false;
   24.13 +
   24.14      status = update_identity(session, you);
   24.15      trust_personal_key(session, you);
   24.16      status = update_identity(session, you);
    25.1 --- a/test/revoke_regen_attach_test.cc	Wed Jan 17 11:16:22 2018 +0100
    25.2 +++ b/test/revoke_regen_attach_test.cc	Thu Jan 18 00:46:19 2018 +0100
    25.3 @@ -48,7 +48,12 @@
    25.4      cout << me->fpr << "\n";
    25.5      
    25.6      assert(strcmp(me->fpr, prev_fpr));
    25.7 -
    25.8 +    cout << "New fpr is: " << me->fpr;
    25.9 +    
   25.10 +    me->fpr = NULL;
   25.11 +    me->comm_type = PEP_ct_unknown;
   25.12 +    myself(session, me);
   25.13 +    
   25.14      identity_list *to = new_identity_list(new_identity("pep.test.alice@pep-project.org", NULL, "42", "pEp Test Alice (test key don't use)"));
   25.15      message *msg = new_message(PEP_dir_outgoing);
   25.16      assert(msg);
   25.17 @@ -65,12 +70,14 @@
   25.18      assert(enc_msg);
   25.19      cout << "message encrypted.\n";
   25.20  
   25.21 -    cout << msg->attachments->filename;
   25.22 -    assert(bloblist_length(msg->attachments) == 2);
   25.23 -    assert(strcmp(msg->attachments->filename, "file://pEpkey.asc") == 0);
   25.24 -    assert(strcmp(msg->attachments->next->filename, "file://pEpkey.asc") == 0);
   25.25 -
   25.26 -    cout << "message contains 2 key attachments.\n";
   25.27 +    // cout << msg->attachments->filename;
   25.28 +    // int bl_len = bloblist_length(msg->attachments);
   25.29 +    // cout << "Message contains " << bloblist_length(msg->attachments) << " attachments." << endl;
   25.30 +    // assert(bloblist_length(msg->attachments) == 2);
   25.31 +    // assert(strcmp(msg->attachments->filename, "file://pEpkey.asc") == 0);
   25.32 +    // assert(strcmp(msg->attachments->next->filename, "file://pEpkey.asc") == 0);
   25.33 +    // 
   25.34 +    // cout << "message contains 2 key attachments.\n";
   25.35  
   25.36      free_message(msg);
   25.37      free_message(enc_msg);
    26.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    26.2 +++ b/test/test_keys/priv/bernd.das.brot-0xCAFAA422_priv.asc	Thu Jan 18 00:46:19 2018 +0100
    26.3 @@ -0,0 +1,59 @@
    26.4 +-----BEGIN PGP PRIVATE KEY BLOCK-----
    26.5 +
    26.6 +lQOYBFpctn4BCACx7hSdsA+AnAQ+VRT8vb820MUhgiZ2gBOmmjZt+R+U8jGA0RFT
    26.7 +OFGWMNwVNNDV+FFES4yTbbmH3JPEPfRTKzcBJrty0WfTrCQ65lv1GBmGPO306pg3
    26.8 +/AA8n8e7SAVwc3fHB0oImQTkiN9Jx13KvFhSm32e4DWlDEYEIOSXY5ZjmczMoLTq
    26.9 +mwbf0ROXI+aXh793AS+oUlxl8CZJxwW8EmLiHAc2KJVXubJCq3nkwtz03/NvgCYL
   26.10 +M0cXds/jNrEEpTbXjx7pnVJC1tIrCrFrKChM4qUpcWqSPwn0pIs8EP2FHS5Ou0MK
   26.11 +O59bGVWP5EPy2gyS8bfgtWt8tL0jilBlUa4hABEBAAEAB/wM0c7+x4BubznntctD
   26.12 +zyCs6zYbd8bxUxassmqz2gxPonLfnvCPyDx/ROOZIYuJsbuaiejwdv+JjY0V9Agb
   26.13 +n+mgIHFxUIDEYaA19YKa8j1l4b5GnvUQVOHoJvObMjwLbJOs2CvE2nrdmQuhbgb7
   26.14 +bujcLCN3uXFpWVeIFPNIrF5ZrEx8g+Znv7pR1p9LeLaLoizn1GB/DBnU2xQvLKY1
   26.15 +2MRyl3yd/vFwynVtcKVcpmt0sZpBJaZx335OWfE27vOEK18iGWYzEXCupZPCCCKC
   26.16 +kUQxu6Rm0cieT/0XuFNpG8hsszHzb3s2Am4S75cxhhW8zCINTvFGiWdKVIdlKT3O
   26.17 +hHI7BADKk3ElgtyoSlnvS3Cz/f+Rmm65bHcTcWplHsls2bEgRKZ9Zeb1nHxcTRqN
   26.18 +U/9mPrnCpjNwVTEsXORiiSrnpn0gyNloDMtmbM2CtI/+71/2xhb+nfQ3C07C83dz
   26.19 +ynas82Cz9iMHJfGR/W/AYplM65UQ8wfV4n/eWm6r54UCM+bFgwQA4Nq2DD+EWrjM
   26.20 +qSEhe0jvxCPCwod5UqTm2olTq/Wnrh/cnDGZKyUQ67ywdijFQ+L963UUdJrk+Ldu
   26.21 +ms9MN12xWrJguSQ0x62c9uUKgOROEPXwSM6d5aPpToLiRB8aMOF9qQToE9XjIJDQ
   26.22 +yHfjaCXdDK3IwtsfH8tPxyM+25Mu0IsD/3a8z62/0w7yg/YUj/52zJWvM5MnBYl6
   26.23 +E3rSMclcNXBJPvgQAGXtxYyAYC2VBfNclm7f0tqv4nWDx+x43BL4vDgh9lwHh3eN
   26.24 +1vbhrAhp3U/RNo928LmwsD03n8XQ1rY7b6ixYJ0LbzgVJND39eLinzi2IaWzRAED
   26.25 +8nq6V3ua/yv3VS+0ckJlcm5kIGRhcyBCcm90IGRlciBVbHRpbWF0aXZlIFRlc3Rr
   26.26 +YW5kaWRhdCAoSW50ZW50aW9uYWxseSBFeHBpcmVkIEtleSBmb3IgVGVzdGluZyEp
   26.27 +IDxiZXJuZC5kYXMuYnJvdEBkYXJ0aG1hbWEub3JnPokBVAQTAQgAPhYhBPjOD34k
   26.28 +6xkKL8v9ONSwiKfK+qQiBQJaXLZ+AhsDBQkAAVGABQsJCAcCBhUICQoLAgQWAgMB
   26.29 +Ah4BAheAAAoJENSwiKfK+qQi+OMIAIXUeU2A74JwnbtO7XzGZ60j7roCAOAn5AHx
   26.30 +GNnWlguRIk0it+7H1PPdFMETWDKATVesmNFVATQ1vs5/G3TmHCzie/yjLMKHg2iv
   26.31 +ouQhEde5x5sbI+w501GDinDLihJC1kIrBW9MnEE4LniXZ1SBXoTwy9H7vLhvgckH
   26.32 +p3JL/zT3Z7hn/oGT21Der/smYJp8lI3gLOA52eFCiwtzn1Rv09fjUYIcuvHFMl9o
   26.33 +1yJTu/hLSRBwJliLdvl/HQLiM+onr7NoJCxdnvDrQUqMVH4qjDAHJKZMjjy5TLko
   26.34 +TAcLeohO3NlMSXmRIhDUIr6S34hUNdrHIopORgajXbfKbM4iAL6dA5gEWly2fgEI
   26.35 +AKnO1DQBmoB4KlrcNKXlCazCWp0cLPWB11cIGpb0DGeVEndCxQfBGRocZs7zZn1M
   26.36 +pEpzRx9Ae/R/o3w42IaBF62RXOpofq2WSe/TYI4QJJvSPJ168VuP9BmNeARL0Q1E
   26.37 +AMro483LCCUpGIOb7uC9hn/Bi1OmK956tJqEOSYqrpxkY3kw3CUVknDCd12nc7zB
   26.38 ++1KQDCYSqQVZJ5zkagr65E26SXfvzf3n/x+UB9FhnIE2zzkUJvsgY7s7z/XL/NXD
   26.39 +uKjPbbIL6bhhP08koljCN49q0pSlB+Evw5oukmON46JSe1YymBzVA49b73IrSVrX
   26.40 +KT0tbKVguiUG3ewc9aunUpcAEQEAAQAH/jIgkucZVBU5o/M3jzkr0DvWEe7QOvts
   26.41 +jXetNkA6ohDP4mgfZ0+fMrxRBw5vruEtR1CNEEFLBWyLY2UP2Od341gDEeVG3KJ8
   26.42 +u63W/eliHZR8LxWkDezkJYCHkRbflMJwQTWlI16EYY6qv4hWd2GTwUkkhu82Hjwq
   26.43 +h/cXMlGwhuQ2iTDJOcCmYh3ExgVrhc6XPCmtPSuG28KR2sN2pRDl5pPH+/wbKNVS
   26.44 +hk01m9/kDdDMSi6U4PMPZ4Sq/0mzlfWXeD6Itn2vKhLnEFp3vYr8P8m2+AgWtM+D
   26.45 +7fPAf1O07xNWxDkNgnolgluoU3FrpifYwaaj6N6rFGsBEv0Nfwju8kEEAMiu71QB
   26.46 +kLf6Mf1R/lRWEyP6/HPiNu9fMHnV+ml6VFyiaJCCZvUBbZOKDOmedVS3pJXGp9uk
   26.47 +G6CLSqlCghgPK9M+ExtSN2JrgNPU1bXSMviHVMq70HtUeo/wHPfIoYpQ+VRiu5i8
   26.48 +kZgkCCFCKlxr0WTp3tI51xu0g0fQOrpT16hXBADYnTG7WYMHyDCO3uh+/zErhw/r
   26.49 +6POZZWegnPteim6GN8X8NG7GJnQB7Voqn8X7tAcKPgCQBEdOltz3PWWDm66E4VFs
   26.50 +e7Bau5i+SshzKXdKwYVkGH6h8YWlJjqOm3m9WCAUg517xy9VMyxihpTvZs2Wwtk2
   26.51 +TY2/Cv7RyrXAAvw/wQP/XQjphddiuST6wKiAWsbzYhuof3zyXX3fy4vE6rNxvl/D
   26.52 +RAOcKFex0Q59K0YOePRYrEjQlUoPhqyeQGUp7DZsyiTGMpmFVRqg6LcmAfQdO62y
   26.53 +53gEc5cr5fnZOKavu5agP/ktry28z8pzg0pXUkqcdqxluIXp9Av/Dc+aB5VzQXtG
   26.54 +k4kBPAQYAQgAJhYhBPjOD34k6xkKL8v9ONSwiKfK+qQiBQJaXLZ+AhsMBQkAAVGA
   26.55 +AAoJENSwiKfK+qQifC4H/13K4LnWFOqSAXzzqnass2aY++1EVXRnMDdXsp3jU17t
   26.56 +CFJZufoNAw7vmInrCgxMViUjfV6DfyDsrYynDWfIAS6FO3ThnFtgkgekdTrNg6DZ
   26.57 +OMl7D9+xaP0S/fVITZz5XRqs7amRkojftQHJMpPNoXwcGK1hGLgPIvN4cbLIRvnG
   26.58 +SDhkstFdsvNbC92z2upit7+yq9eW+Kn2exJRszgbZ53ghmhNy4CrhjJC90CsYF1S
   26.59 +zsDlqwc1ET4vjV1pCnjyVk+pNsw1V9kKMm8icFFwB57xX5Q9EdwMipNaWWg7CHMM
   26.60 +8+Bjqsj2qHs0LNWO7eQyr8Uj0BwfT04Wwz68iD57lEQ=
   26.61 +=GIbJ
   26.62 +-----END PGP PRIVATE KEY BLOCK-----
    27.1 --- a/test/test_keys/priv/pep-test-recip-0x08DB0AEE_priv.asc	Wed Jan 17 11:16:22 2018 +0100
    27.2 +++ b/test/test_keys/priv/pep-test-recip-0x08DB0AEE_priv.asc	Thu Jan 18 00:46:19 2018 +0100
    27.3 @@ -21,38 +21,1478 @@
    27.4  W5pPkaJqREs2JRmWh9FtglhnqzjfZwW9KaMcYgORPvK4pXMD1gHNewJl9LHvKLIr
    27.5  g1MlsNmpcOUhNKS0Z3BFcCBUZXN0IFJlY2lwaWVudCAoS2V5cGFpciBmb3IgS3Jp
    27.6  c3RhIHRlc3RzIC0gbm90IHNlY3JldCBpbiBhbnl3YXkhISEhKSA8cGVwLnRlc3Qu
    27.7 -cmVjaXBAa2dyb3Rob2ZmLm9yZz6JAT8EEwEIACkFAlh711YCGwMFCQHhM4AHCwkI
    27.8 -BwMCAQYVCAIJCgsEFgIDAQIeAQIXgAAKCRCE2SF5CNsK7p1nCACNWH+sADtb9OKO
    27.9 -oiZX3JXbO66D7YaCsuIJfh1ZtViessDl6uuCKULkyZOhRGkMMwrlMetfSz4/N6Hx
   27.10 -iPPNKfdDnJnP0gX45KOsVKB34VdgvYN4kUKL4hvAAxfJC5nI+JXuOwUbxs6FRYkQ
   27.11 -rYYv1I+qufdaCzAWc9KLeyBpp7uYNBHOOELrWxvAFMDPMBSioCwGYU04cJsBLXQC
   27.12 -bsxdyFiZSgAS1A/oIEQ87fZtPYuq6SHrZB2/bsDiEIFKDmK91zY6phZtgzVi77pC
   27.13 -K6YL/GZBi5ZSBXuzVFMjeVwJr3ajsVDs78FCmKT+lcmAvZleEhMKpovs1Ng7H1v3
   27.14 -EQU2jhOpnQOYBFh711YBCADZlca5RzMLUOX42+krKFcK9KGjanackuKlU0DbDh/F
   27.15 -8x3ouVDV3+Nu4Ti6/fxtnuaSW7ZmssOTYGJKaGqRjpNwe6HjY1giMr5KO2J8TsOJ
   27.16 -aKhPyrgCzgeX+a4nAIE8P8CeEiYOEG10wyZ1i3PH+JdeAmDR2/YoRAB5XXaKAR+z
   27.17 -1Aa1i+tgdw+nyZSN9hFvOjruyoMdvkcEo94x3Ylw4fVkzTl5zlyss3CgRzJa9EW0
   27.18 -BnpH2OVTi6S39o/YzUidWzysu2I2/DhUcGuWDoDOXD1ILULhUIC4UF12t0coBtRP
   27.19 -IG4MoKya5UkiVK0j6q2PD0yj5EJkvyn77NSAHM4Fih3NABEBAAEAB/wJIOEA9e08
   27.20 -zMyRJ7y9DEi2k3PSlM1cHUd38ym15v5LQjtff6LWDjoO9VD5e11jRfbbbhCVd2uA
   27.21 -G9uTzpSl/arO3cj5broMWT+lgp9LosxOT/87tcAJkhY8eIOnbDx/yBbvKsjA70yA
   27.22 -SQ2sgci+O34yOfxQ4Z8Oqmewr8yg1pI7a5Zz54oB/6y+VBjqPXSbW3V1Kb99xEfD
   27.23 -E5XWxPag8uPn1anExmvU4IfIlzNOpUMcfYbevhVOkhpFxwXtsh95SeGRDKwsniUa
   27.24 -Jq4XashfRq75HueUJnDV73zkPc0YZYUMzybKlF0+tOT49dIBJR4wk7JXDePF59nu
   27.25 -GpvnXL6FtoEBBADebS+XVp3g5QSsctyBoH4sA7C5RSlHUf2kKILRF7DYdyJMgEji
   27.26 -iD3BM++PPnW2Gime43je8LDJOsqKCncMw/sn9Lpdyz1JJkNlgF3PGVHzomrSafNv
   27.27 -9gv8SqbGI8niiWVZH34NAr7XrRUUZE0Ggzc7ehiyOjWRG87ees0w45enTQQA+m2C
   27.28 -7f0fRTMScVyo6l9TMITZY9hS76Zre8jBhUl0cYrftU1M/04vU8s4gIk85WBbE+Ir
   27.29 -Cr91hiqyi1lLpndAz2gMct3F8YbtjFZRmqhTZpNh0kVc4WzPf7Ctu1SIac3nz4oZ
   27.30 -v3ooDk/Ks/xbd9526q+1mxQuFmOU59MQxtlSEIEEAKJgb1Ri6oFPn4dSJUYv1HuV
   27.31 -nUgkmnJtrf7jDOPPu2PmPSiWu8/QGzmHwbjO2erV2Wa46wlJ9GYifCzo545d92Yl
   27.32 -IkpNok7Btkz9AQjkJ/QKPgA/0K5cKVpSnIF16fcddSK3uc2rG5fRypfVbONvQ17f
   27.33 -VrU8gWYvCLZE91X5tXM3SoGJASUEGAEIAA8FAlh711YCGwwFCQHhM4AACgkQhNkh
   27.34 -eQjbCu6LMgf/Vbtpj0Y3swMYWDahLZjjPKPzvaBnLHnmlZJS0culFItLbWTZB7Wu
   27.35 -Hn/pv1pXsKF4XNnl/zK8HPEEJiVuA2eWGsA9XgqBGYCwYs8zhJFkeQ55iGGuMhGy
   27.36 -PT3ie153vqjbDXGC7ajlksEwP3ESrkLjIuHWov8karzIXKiz4M9qnrJY6OmNfO79
   27.37 -qxigEs5BuIZNWS/Dy1de5RAfQgSVvD3uXX5cLUAO/FxKfHVoHdL7JEcrJGf91T+u
   27.38 -c9LDOtccvZRAZt/l3M7qRNudRF3HnvunsfNMi1xLzz340lVKO564mYT38yAX9zhk
   27.39 -fkPQwHlDzt8ruC4IUKQljSKCwngrpl+qyQ==
   27.40 -=V/XN
   27.41 +cmVjaXBAa2dyb3Rob2ZmLm9yZz6JAVAEEwEIADoCGwMHCwkIBwMCAQYVCAIJCgsE
   27.42 +FgIDAQIeAQIXgBYhBJPRnyStb0xLqRNKr4TZIXkI2wruBQJaXUQHAAoJEITZIXkI
   27.43 +2wru1+UH/RIteVXEUBqyJ1S68hn5yGNiR/3OX012TuqU4HB1mt4w+mKCUVwEInxX
   27.44 +ivpWqQbkWRNoI6vkf7cXHEPiFOdjuek4DPo7D7KOXcXWvttMz+S+HPXZk5PerDGx
   27.45 +z8bruvfbbi63YGqgRrBIcdfX8jIe5GmEd3VVxjZKEDr0/czwWn40W3RAEm2EZfg/
   27.46 +RnxxHaW3TBURwJlkRGA0IrpP5OibI8jxpx5OgrFeZbbFw0IkNANiO57XNNmH1CL/
   27.47 +ggYZwvC4h8WX/b0w3D1r020jgo+M/VS3DfeSn/fMzV5n/a6A06poARmPFOsQN3qy
   27.48 +/4hf0EbA52aEJq1ucqbXtlpsuDeVX5ydA5gEWHvXVgEIANmVxrlHMwtQ5fjb6Sso
   27.49 +Vwr0oaNqdpyS4qVTQNsOH8XzHei5UNXf427hOLr9/G2e5pJbtmayw5NgYkpoapGO
   27.50 +k3B7oeNjWCIyvko7YnxOw4loqE/KuALOB5f5ricAgTw/wJ4SJg4QbXTDJnWLc8f4
   27.51 +l14CYNHb9ihEAHlddooBH7PUBrWL62B3D6fJlI32EW86Ou7Kgx2+RwSj3jHdiXDh
   27.52 +9WTNOXnOXKyzcKBHMlr0RbQGekfY5VOLpLf2j9jNSJ1bPKy7Yjb8OFRwa5YOgM5c
   27.53 +PUgtQuFQgLhQXXa3RygG1E8gbgygrJrlSSJUrSPqrY8PTKPkQmS/Kfvs1IAczgWK
   27.54 +Hc0AEQEAAQAH/Akg4QD17TzMzJEnvL0MSLaTc9KUzVwdR3fzKbXm/ktCO19/otYO
   27.55 +Og71UPl7XWNF9ttuEJV3a4Ab25POlKX9qs7dyPluugxZP6WCn0uizE5P/zu1wAmS
   27.56 +Fjx4g6dsPH/IFu8qyMDvTIBJDayByL47fjI5/FDhnw6qZ7CvzKDWkjtrlnPnigH/
   27.57 +rL5UGOo9dJtbdXUpv33ER8MTldbE9qDy4+fVqcTGa9Tgh8iXM06lQxx9ht6+FU6S
   27.58 +GkXHBe2yH3lJ4ZEMrCyeJRomrhdqyF9Grvke55QmcNXvfOQ9zRhlhQzPJsqUXT60
   27.59 +5Pj10gElHjCTslcN48Xn2e4am+dcvoW2gQEEAN5tL5dWneDlBKxy3IGgfiwDsLlF
   27.60 +KUdR/aQogtEXsNh3IkyASOKIPcEz748+dbYaKZ7jeN7wsMk6yooKdwzD+yf0ul3L
   27.61 +PUkmQ2WAXc8ZUfOiatJp82/2C/xKpsYjyeKJZVkffg0CvtetFRRkTQaDNzt6GLI6
   27.62 +NZEbzt56zTDjl6dNBAD6bYLt/R9FMxJxXKjqX1MwhNlj2FLvpmt7yMGFSXRxit+1
   27.63 +TUz/Ti9TyziAiTzlYFsT4isKv3WGKrKLWUumd0DPaAxy3cXxhu2MVlGaqFNmk2HS
   27.64 +RVzhbM9/sK27VIhpzefPihm/eigOT8qz/Ft33nbqr7WbFC4WY5Tn0xDG2VIQgQQA
   27.65 +omBvVGLqgU+fh1IlRi/Ue5WdSCSacm2t/uMM48+7Y+Y9KJa7z9AbOYfBuM7Z6tXZ
   27.66 +ZrjrCUn0ZiJ8LOjnjl33ZiUiSk2iTsG2TP0BCOQn9Ao+AD/QrlwpWlKcgXXp9x11
   27.67 +Ire5zasbl9HKl9Vs429DXt9WtTyBZi8ItkT3Vfm1czdKgYkBNgQYAQgAIAIbDBYh
   27.68 +BJPRnyStb0xLqRNKr4TZIXkI2wruBQJaXUQTAAoJEITZIXkI2wru7mcH/iE6LKxN
   27.69 +Sgd92tsVXyAz4hAJMgWd4yrRlNyUCeeKFJVEvQAdu8ysazd6atlGNdf0hLAJs7Ln
   27.70 +zE5NQBwLdfJixMMm2vb6+EKN+hGYYJJL2GW24CVGCkc895yykdPDtaV0PIRS878P
   27.71 +5mSEhuZNlw9SDZotb3ipQRfX04jozScsYPxxXYtJrz72ghE2NosU3M/pEHMzTBfb
   27.72 ++KJ9wUmQciL+c7RVpvCTGb9QomdZpuLZEOAqLdbUZ10YggXvLI2xse+JitlG6uB6
   27.73 +Ieq3dGLNITOgc1pKmo4WI3rsY/FuHhuYfT7g68svEiwzmTwzeKAJmFvQ5LWWWTHx
   27.74 +5IemibOQ9C5dgXeVA5gEWl0mOwEIAMntRnGKBZZFyvx0WmbrUoHpAktcH/RN+AAx
   27.75 +EOixLZB+zrWW3owCzEoM+2dhxPXMfJCn/N/DI3r6P0DPWbXfUhtcqW70YMEUAoVV
   27.76 +sYKAc1nABMid+v7uxtL7xmuKwUzYhGBl2NQ+/cgvFN8dB8lhy9DOnYT9p5ZUy+Dh
   27.77 +dHb8261/MWOr/sW0oy+xzFncvnDkBKKQUkzW6zn9vXTtCPKtgq70IOzwmfohAHcH
   27.78 +UZpLOU71cQeRmaOIC6tfHGprUMWFE6oFLrdKwOcy66IwiH/s7zOEWfCtlV8YYaA1
   27.79 +4BzmfNbE+w4Eb0WAsvYwnFlMPNSL6En33Xuj9oT/fqNTzd/o+6kAEQEAAQAH/jto
   27.80 +9jrdkvs9mZVhXl+9iM70EVq+xiAI+JiF1yW/S1qiFItU0jF7eUOoQieOmnZ/LX8a
   27.81 +DcqADWZXTljxKMHb7LpkLu2YNQdZrcwxBEMTK90SI9YqtPhgpFra/OwTLQBBC+GY
   27.82 +1YzM47oMMCXc0rercF4FDE9emfofBMUrUCraBoAqz93/ntZFeeQGq9mGdDA8R51x
   27.83 +1nXE/wFI7EppGhDiLxnKYpFx47+eUXn/d4HG+qjDpont6IkNk2Rjr8aC7T4fJsHl
   27.84 +N5yrnZDOYcV1gS9putksdV3ctLQVOtuNw2EnfAh5St2mJJIT+ujcA+VQaNtVwnwy
   27.85 +r3hmY1q6FJeZs0MAmMkEANKxbJsGGSsxcqpXkw0j+aMTo3HhT+5vveMzIFeRceDS
   27.86 +SxDKpnUZzeRiloQXLHlaCxUeZ4YZOjf8zy/rSGcr4VaAzHHY4QjR2p7i/e/5BJkp
   27.87 +9hsl9vKPq1vKp14hnUAtabxQxA7OD+45BgJVi9M1om6T3jrEe6r96846HY51sGOj
   27.88 +BAD1WUZBfwaOTfO5JcJNIeSe+sq6/DJaGC8n/L4b28yqmSs47AkFBNWhiEetqIb3
   27.89 +MN5dv6EOKeoIp/ZxmwIK9rQcUGNV8ylMN+r/t8yEOmU9OX5VLAe43ZRjh79TqRee
   27.90 +pMWL6sbkiiBuiTB8hdvJZtmSighhYUk5bhkJDM170HP4QwP+O2Z1/qDb2t5o2rQl
   27.91 +P/SbSEMWnBNcJIi1Pf0cEcNTRa37OFXnheliW+I8ap///a6fjJAPenAjd0RK5+dF
   27.92 +Eur0kbx5hv+d8T2KJe9QhdZRllaqqOU4+9ndfPXmNf/Xb1LPVg+h67U/FfXFYiZM
   27.93 +qLE6dVGkcQ0YXfEdvemPSFvG6SREs7QxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAu
   27.94 +dGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBEQtvu2faUNx9r+0
   27.95 +F0BCeJwpy2+1BQJaXSY9AhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheA
   27.96 +AAoJEEBCeJwpy2+1/5UH/2nufLMaHMjRF9is4m1B7wvdJAooemvwmVIXBgjumEVL
   27.97 +A/oYT1whKThiZEi8FTMaQB3zKpnCOV8hve/xnFH/zNI+RgIYZrtrVQT8jxkKGfC6
   27.98 +u3gUBiq6A1QEhB3+HJ5/Vnxr9ZMzKNyqq16nUkX48eekyLMl739Wyy8l/bnqJlUZ
   27.99 +V1YiKgptEs0K8iqRNpjWmYL0Va/l/X8CCzf13eMu1cY+JeDcEDrglmM8vqiHGs/Y
  27.100 +/6aJJySk71YB2drr279AuH+JYUCmO6EntJX/5bZktOzH8FN3KS+GTnHupMzDTIsQ
  27.101 +spepadZfylKJkXTvxJ5lqNbM7RSmt4VgPIubWkLoNECdA5gEWl0mPQEIAN2cbAy0
  27.102 +9RNMf7o4Slpmc4SVoT/b0ywdvF8u+EISDJTM9Azg13j7q0dl20+JgIOfyKKqoea6
  27.103 +MwDtBtVRbAMWQjxtrs0S1eWM04u+9vPbxragoIFKPFpTWvtqVCQCzOPbja9ECRHV
  27.104 +SpXNAj8tEz+344LSzTRDpwh2KL5FKClyRgO7bFAIum9Z1EZVuVXL3oYhJ5emLyBb
  27.105 +VVhVonW6Rxltx/KiCk0qGn36AdnQXdrdtrcrVuFJSLht7+VuWwK2/2a18jBbNsjx
  27.106 +4p3oMGX4V3G36wfBf1gPAv4e8jhN6d2jDN/O/HsPoDaVrBwHHf/0mM7bJR37RUgx
  27.107 +wTITba8ahqLU9nUAEQEAAQAH/A3WQnjYo6S81gzOjvXuB7Bzl0nhc+IBSU24JRAb
  27.108 +CGYSFfrn3wxSynL+zR6+OyP8yg4+ETXS0nRwWEjheJkIvsH/JzbuwiQ/EsZa+hhn
  27.109 +1JR6mwr3k6UgJ0IjdXV6J0ji4Inc+aP/aVTJJCbFrboAxVfZya5FuxwwJIMc1lEg
  27.110 +LXb2EyCDnmEinmf1JlUYRqbH6c+yc+Ek5FIHleA+/szCLjAajJZFJuiivJPuN4cq
  27.111 +9doZUEZCyPXACRcN1Pp4Ta8HoVnQVlggTeX7Q3sunwpSFclgqG0SK5JA3XpUfMQY
  27.112 +EoEP8lEJJspMEuibewVWVaoTIE8oAeM+d1C0JSP/Zb5ErtEEAOiAGZeTvt/znivI
  27.113 +FjsLaeKSGrbXVp/e4xiWLr1K/iVetxw/CmDKZxlCfsgrsOCWqNbSX+2NNmOhrNaJ
  27.114 +aYz57Z44NgxqxniEsYdT+4E4Haegoa3JC/jJD9hH+4yTf3FBlNd8WZqJWJMUezPD
  27.115 +MzMLSUf/wNye1QZTCRZBVlS85ZgDBAD0Ao/cvgOV0d5yoxE+cIuwpq+IE2r3mzx9
  27.116 +3z2FkVCrsaaR6frdn/OtXdZ/k34aII/dbQ/xSC7cpmtubvZaMWR06UZwKDOLvQ0H
  27.117 +QmdNSEvuGmWGIH3eo2OzY4+7GEm7lBBkft6SmUpJCKX2ssk3sYCyrxmPvxyB3hK8
  27.118 +BKFNUiOaJwQAsOe2O/CzioIpLikkXyd/w66Dkwc0fDuJQlei5vv08MEzr1JV/qcJ
  27.119 +tRHwzdkILZAMl1Rld19vuOQrMkUN2bN+wzY8odTDNfznL2sKIMJstymBNVOxCcAZ
  27.120 +E4kwimoWBDqeqmRiD4w8Ertgcl51XpPXQrHcz82fOiIvYAePXPRiVFg0j4kBPAQY
  27.121 +AQgAJhYhBEQtvu2faUNx9r+0F0BCeJwpy2+1BQJaXSY9AhsMBQkB4TOAAAoJEEBC
  27.122 +eJwpy2+15TkH/jVIGni6Y5fBr7oqMlMDBfnAfSeXNIZhBGutPcvYStzRhUFsB/go
  27.123 +RIlXaLsNcdg+AU9UlkMpvi9vggqIAYNQf98RnKOTLzl6o1yb0tmxbzOT0C9qsN/5
  27.124 +KpNC0eiQdAr7f7N7Zf6sGD2Bk3h+fsARZVG2pKCZLTaPkoh+bd7dPVLfr8vmLHfn
  27.125 +u+4fc/Il1FrKxD0nVSks5KzpR+ttfrwoJrZOwpADtMM7Xmfj5jT2XHRcZRo/n8x+
  27.126 +eGnVQicYlNzjh1RTu7wlaqdf+G1t38COsTCz2SGqyVYmTMlozr1B0vv2IirAmkn3
  27.127 +NYueChgKzi/AevtBfqzsoRhU9Xem9mS1mM2VA5gEWl0m0gEIAMpw7llUVEl0+18Q
  27.128 +JnfbzuxvVoyVM2JvvUjQ8f5GgmHqScKYZi8Of1PHN+jlf3F4lOcKomYPBHqipcOt
  27.129 +YNkj7h52Clu3vrBk1g8Ku1kD8TQL+k6RM1hc96+34rmt+HkAvYgEnXRpST0wkF2I
  27.130 +Prs1yL65Ep4xICMG55EZfbdgrn9WyN2iSAaxdUeG5jFzLMm11VTrnz+RQ2k4IwsE
  27.131 +MxUXKrxQ7yAVqBaDxDF7iyAQQy3DUXD0jVaz+wCriGNjQV8mFYa2DUgyr9vUM/Fc
  27.132 +wjIGqYqJxWJsXVL8A00tMV5ESs3o7WEhvbDu/KLfFOCsuDmAa7k7IdmmVy54511a
  27.133 +GbceNj0AEQEAAQAH/R95MUVIHBaTjmU4MJLf5KrToIQYyjVao/YHLihXM/wfHbqY
  27.134 +UQKt4VPYHDQkQg0VLylAeQEfApZCZT0n3m/D60hnF7MsvQPVmYYbKAdt2nk6B39h
  27.135 +ibcKNSPnleNCTegaGl1kQkqP9+gAfeFcxkv6z6v/QArCHnnzn9rqOKZi7J41S6Yj
  27.136 +AssyRLiMn7i7mH5jx84ZgHwZJ8yUS/uWFhGbUrRuF2X3WblmnQlOv4Il23WrN/HS
  27.137 +TQlyDhTW0V6JnkkzU+W5jjIoO01cVdgCZdReLEyBJeh61mBVgyeD+D5FW8tYh3l2
  27.138 ++wFHNJ4ZLxk+NkSVjx+4B24xaTCKbEtsTfOslaEEAMtTtQAzIpU6GF2YMD0dvqu5
  27.139 +W2FfESWkjRs4IwXqFC3KlY2DlhZZ0un++8kvkpCIIC66v0Cnk+fN5Yh7gSijPElb
  27.140 +LsSR0zJeQcy5CIScs7NF6ASYIsZmSMeSCYnEDmgqNofY/lnOfm8DEwy7vCBqycdC
  27.141 +r/e/aH2ItLo4zcXyBDKpBAD+4nn1PCCaYpJ7GPbtT3KlzeGh6QB1QrfuRkCir5y+
  27.142 +/ew6ly2X/93w4yJY0YcUUgD2akYcoEYmxgJevocMLQ+76aoCSzqLcfkifn9b/Zfj
  27.143 +e4tOVFTS+Cj1GoLcIgwGcz9aZsknbU0N1IO3e1zLS0NZu+KYn1VbkiDRHP7dAQL3
  27.144 +dQP+KNH95i+pQ07zn2GFZZa5vMCKfds3DggmKshwSzSNU8rxhGi/MnhmXASGVhp3
  27.145 +3ny9ZbL/qzQOPIkCn4VgpYiEZOTQZ7CirusKftXYkbWhtWcVMIJXivS12Ps2eJcK
  27.146 +KUVWDffEuV9a9A+eHcB4c/AHvqyhV60gtAICLBqHRDDK/zgur7QxcEVwIFRlc3Qg
  27.147 +UmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgA
  27.148 +PhYhBMFOlnkDKecxT/WC1fAxdmAvZZ9dBQJaXSbUAhsDBQkB4TOABQsJCAcCBhUI
  27.149 +CQoLAgQWAgMBAh4BAheAAAoJEPAxdmAvZZ9d6F0IAIpVRoHbfaZ2goawft6Mg6dP
  27.150 +rwznM90bDI9gq0UC5Dt+nShUhgTJ4wSz/iG1XHD565ML9HHkMsQrZazstNM4lJqq
  27.151 +AwdIOMAQVd3/sCFX/8bEPO8UFQDPB0XcdNemNqfbC1n7kQWAFz9GV3Dc3LJt0cDT
  27.152 +094G1Ta1gyuVbuJ1ZfI3McQZvohebobIWkx0krdvHw2AfLBzItuvpzBOSR/ZHGe0
  27.153 +xK7FcmFxfPQHNfNSyOSBsfC+MILvwkJYTuSRCY+Lk86e9pp1K2q8xGGVu/tdVRSF
  27.154 +Giw2fuhEpL2b/daxaZ89qR9y+r3H2ycwJBTbpXIrvsbLJB0nBWEXUFiHJbunbEud
  27.155 +A5gEWl0m0wEIAKyzpLNBSEf6YWKIgKbF8FIbk5UI5e+wF5slB9hznmTqMWsmVDYa
  27.156 +FOZBWq4IkKnOP1wB4DiaLnjmwSE49Fw4tyR5B16frhRX7cYJ8o9yFI+6WA66YQlf
  27.157 +Quhf3Okfov0JA683OkU690MaDmYbmU5+V0LD2tHcXPo8iTp6opUA2m8XnZhwUZxx
  27.158 +2s3X0Gru9nKcvrr8Os7cNtM+THyUuUK4yNGzKM5GojuoGhikM6ULPw4cfVuHRMMn
  27.159 +AMZMx5sooJZ5yBx5r/FBV+os1TKldLpNXVr3bIMVpU8jU3ca4t2qOyUGBY8WsKZk
  27.160 +o0n7MGoea3bzY3l72BDHrqHAduBiO/tOPbkAEQEAAQAH+wfIcsg3TXQc9w2TPEUH
  27.161 +z5xLrNt/Eqm6JF40DYX2M/G1UjPTfuEPTNjRoi4MqcRVTKqvVPUIEccWEycVo4GS
  27.162 +dsJ4h9n+VUCKc+dEZH+NcxrFGZnUUXI0LlY9l72T1OsVYGqhkQk0rpcCEhsM7FxK
  27.163 +ulECdZaWmUQXvVF63F/dsXpnIY7WCnG1l/kF6pnJB2H8e11bYWJ8RZOrvO1ACUS9
  27.164 +Pgll2ykTPqeMw2674IeXH+r+MXqYVzzkEchOtLj6E0P+FoeiVsJGoAah8DYH/nkY
  27.165 +TjAwBW7GbjR9gbGzquFkb82BqwqAPRefav7e3eDFl0U+UKnoI21Ru87SIAgwLGvX
  27.166 +OfcEAMSRPjGc3H3Ug0F+WYbwn4Osegx5liEQxc26w/mDaBSPgIHktnQ4jZDzhkZp
  27.167 +YvdoclSGULUxtbxO1DH03RGLirKAZhPKxmIF5XO8Lkd+RHjqr1HXsYNii7k+dR5M
  27.168 +GkMTBB+K7/O0UKueOgvDMPjwTdlULOCdiM+scDThbIXcklCLBADg6yW0ttCiZFeq
  27.169 +/W5fg7wE8OMbqnapdkEkvoZg8T17NoyS+46OaiBNHxv/OKdTYbNObPTfz5AnGAp1
  27.170 +hR2OQbnzF9GzliFPfkNoOedsPahPT82TeKdaJBchosCAIc73Vqhxo08fE2eDf7wN
  27.171 +EF9hYNke0hKRN/HY+Qvh7kzP57mPSwQAjlaWGKYkoX9P+JpcTVrw4RhK6t4dHWCV
  27.172 +ZpkMXYVVhPu8ZUhes5fhVmB69eaTPe1UxaLpO5VWxaCLcW4iA7zHg8C5JIqnISNk
  27.173 +K3JN0L1O9xX80IyYhADVRDs/wWOWJPiU1Z3FYhnJKnKNengJWZ3d9gr4DPDg35l4
  27.174 +R6shypIaDBU71IkBPAQYAQgAJhYhBMFOlnkDKecxT/WC1fAxdmAvZZ9dBQJaXSbT
  27.175 +AhsMBQkB4TOAAAoJEPAxdmAvZZ9de4cH/28GI9U6CzlXSs6e9zkZYtjqWwGZSN0w
  27.176 +Kp/pK0W0dtx2x1suxXo/CIS0O0nPq4ylIt5PxC5rAMTeiGXjf3+3ujONem1GEsBw
  27.177 +S7A7PThFQz7tKMlf5TfLp5LnmXVehuowspGnFkESYlVSDKWxIeGB70mJ13CUslsG
  27.178 +YwBI1dXzArLfFW5hC8oMt1vPAO39TsOJQm5Gig2xKNOQrczv0TCdM/Ql+nuTgyku
  27.179 +mOWnEwhJ2G8Q6B7afHYUcylVxGDrZ8GP+owHvs+Ys88r6Aj0VGOHlMtNjlrlTOJ5
  27.180 +prBUoObzPVkJ3uFUdKvsKDBA8fHpuN9mAT3Vmf8FDZvFV177zuTdY2WVA5gEWl0m
  27.181 +8QEIAM9eLiG5hC0uyMRgcdf8OsP4bktXV8hAN99SQ1m4B66470TDuLnSl+zVNrLH
  27.182 ++9IfsvUm68J/KWj65e4jn5wRIitInB4SCv0w/2BjB/xONQmhDxxCyhiUxM59VRSs
  27.183 +zcXO/5Qj3XKLhuWQq8V4KYGpWsA4uMM2HvoQ0hv8s/sqk6JvsiXGo30Qoyg2Y2JR
  27.184 +cy+X9nHN5tazbd29+G0GI8IFUvtA7BsBe1iKOGe14BuPdlV2ZRT3T5WPO6oXDOvM
  27.185 +OQPfhUzN8P1xhLDH3ovmKq0SVigDU9oZRZcqqdaIq8o+3vSfZVHOK7wr6sdeTUed
  27.186 +rvWysy8MsC4GqwgzS3WIM+KM8HcAEQEAAQAH/i6hPfxlbByA5bKLAW6REGHa7mpQ
  27.187 +tLOaBTZZmD2HjWqzuVIcNODMQ0+FTmx7XdwNNr+7xc4RrC0oJiYbqpt8mtNi24BD
  27.188 +jGcM6pAxFK2epHyK1AwF1M4cPfk047nndcoiVwRn4DcOuwHKO2YHNEYs3/RTjPCQ
  27.189 +rfyLZcPXWl2DYHlo/oqXOPUOpaXUV3euL6KeSyhbvD0ZkNe0Aaqbc6PnfHHH0hwc
  27.190 +1ChJpxbWewuFSREb+5LCwWixE7JbPQF4AKi8UIWQgzYhkaTHyjiP872yMci8dH35
  27.191 +Vw3dWnQTUFrJcKc2nD7H8bBj7tas0r3vqb1kcJTKVVCtELY1wWkr6pJ+8SkEANQI
  27.192 +oKitXAVDVKoKYmdowapDEuOTKtA736nPc2kmVLZZrnJH1fF2DoTaAa3BZtz2Jz9M
  27.193 +gioSR8TdSVX1UpYLiSWnOO3keeTsaguKOwu98eYAMr+LxfyFpYWVqRge9mDenlyl
  27.194 +DR24gzFCQam3RBtsbwct2dH5dlfvDF+RLFS29kKLBAD6XeCxljI7vP9fHet6uvBk
  27.195 +oULPjW8vbKmzVzezBzLEvJjjRPzOJtMxm62HNe8OK3ASVOpvKLtXQ4CdZbzg4r7S
  27.196 +itRryGc8/PRYldMjj5p2dmXqeixbIYd/otV1lJCuBOxscszkzcwkAzK+ye203uJS
  27.197 +68OadRLupydhM4gEO7wjRQQAg468d4IhDI0BgAtXjXZttVTSEfT40oLxnUDHJnpQ
  27.198 +vfVz8UdfHOrkud74USNO9q3jhgW/UdOkqvJEqxv11+8+8JixzQlhMF0AVRWrSmjZ
  27.199 +CrbgJXQLSK1LMPEV2oDBKsf69EgSXh2smSUaw+kga+exBkaJzSREVmRoHHVyPQfF
  27.200 +y6VCILQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhv
  27.201 +ZmYub3JnPokBVAQTAQgAPhYhBGxW20NhmLO3qpPVNiGpbY7FarzyBQJaXSb0AhsD
  27.202 +BQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJECGpbY7Farzy7usIAL1m
  27.203 +6lm5FnX5Ja7yDED7EeR0IMTw3GZnRjSLHkDR+SQSOYdXvcHPpk7W57PP+Rvh9tbe
  27.204 +/4C8eaNuBchBdtyLm2CBXIB+91FlHkUDzap54Yr+nSUCQdI6vcJvqx1ryE3Lye4x
  27.205 +Hs+mX+AQc2T5FI2jIUoI38fEhPjZVy/Z0w0EzoBweI6g4Wj+58Wy+lsYtuDFMCvF
  27.206 +Kb7jdG4hGSr1I7e5hZo6o2Kev/wxiOwIG8c/OX9z1Tby+0GoG5wpCWp9MhG8Nklg
  27.207 +MiDtKsfLfwAn5XdPmJaEYp47KyARGI2iiA8VS28tkRGMMVvzFJ7PlTzVU9b0jpl2
  27.208 +WKY9oDellg4ZgG6p4i6dA5gEWl0m8wEIAPirNF+Arvjpu27XnwMwxi20MwwxPoLW
  27.209 +gxBFXph/HfsZL/z+GpNZBRkTNoWuFOIOxZc8OgzbHgbZAsuSM7eiH+mtgYm2DpHZ
  27.210 +cRyltWOSu9o1tPQGMqp/0Pu+F2Lwceuq186s7DLBs5V5a23Azjk0wpNWYjXyi2rn
  27.211 +vT8bcp5/Yfn37+LdDmIrRE5+l/9+3FvLB2tv1ZQCEaz38GkI+rAB3RJdRtrj9Qn0
  27.212 +nYi77r0qmQIruZbCq2cXXRntftaU30OcrTvdY5REdw93wPeOuE75h/pQScnr3s9y
  27.213 +nVQXmzSszAP6TY/T6o+pvuoiZhVzZpU/1SKhFKdjT1UJvzGP4buhtWEAEQEAAQAH
  27.214 +/ithaqSShXPFCr6+fO4Ijzof6pvg51/Z3klzYJpH6soITdfb2HUGHZ6PPH67rMb2
  27.215 +/r9wcUwW2bkmGJe87KrHbLvOWf/VM9t7zIDL48X4Li9WGThM8H/QBnw0YE4RVj5f
  27.216 +soBKqHX+Vr7nzLb74L4YFy2u7zksE+hVfy1IM4m0/TmnEDhpcBtyg6CMPv658Ae5
  27.217 +TDFIAT3isWoPPBvgKEmjw4ku4a2KZgfdWmqurNf01/N6SPYp2XeAnZNYhLYt/CL5
  27.218 +9QFjxuPfwT24LWieBTi8R65txbJradyFvMoQWQHtXChrO7OzHRdRf1D3kV2NaJTF
  27.219 +yqbhrI44x873RgHD8CpZ62UEAPpeEvD8+Uf/rWV32GxTr0kH+G3JsE6Iac673eiu
  27.220 +R2D7IFR+/mKSyZJ+HYNf1b6BglPd/3Lx3txBHfNCJN572b2pPOPCVq6YY3ErOMng
  27.221 +NvM9md+87HMqTux5QwpKkU860klmltfH8RnmpD3beQ4vggNjWn/xpIUmmZM7QiRB
  27.222 ++yCfBAD+Q1jqQY6G+dhOQD7n1TSfUZ26SEtfwNUEygZSkMNZBvNCjiQkoVKI/eu/
  27.223 +S6Y5xT21J/ZNrU8jofjmlb41d8zJ1erxtcp4KMR72LVd5vIKkRtDECzBskUMA6tG
  27.224 +XhvMjHHWdj8X4C6LB4DhpXYZYlofp2Y1xed/G+V1RTv8QQVp/wQAhjhzeHi6+iDk
  27.225 +ZhmpTrG/3ZfAn5OySgtJvqYXABBbT4/P4O/kDx2rJ4cW/zN71+ANl2OGxDpVKlGb
  27.226 +YGM9rbY3SPiHduOPwRbvZLaW/tcrhr6YHtFckNkL6DBBSifiJaq5yfFHxlZk+8Vj
  27.227 +YO/9L8JGNB+SUpiJi6Ikv0VHAy1fhgxLcokBPAQYAQgAJhYhBGxW20NhmLO3qpPV
  27.228 +NiGpbY7FarzyBQJaXSbzAhsMBQkB4TOAAAoJECGpbY7FarzyIJsH/Aja9gn/4WQT
  27.229 +hqFblBcU7KsnYk+5oSUWjhJFTb8ChoiiPrYgunFhpAQUwZ3URHhCXlqg4EIOhGSx
  27.230 +LNrSxx0mOMmAxZumir8gCTZY5ktcTJmnrah6ZNOQkInJ7S/DGDKkH9wir/bpaS4b
  27.231 +zKsixN8yneQp+9T6+oEtPqTiTm25S3LB6JcPaLoeU95H/fqeAXfk1AsHT8ymlcou
  27.232 +e8Auq97tFdQKu2SWbHcIHevPjwY3EI7+SR0rL5bZQR7aonuACueAob3mVXGtJ77x
  27.233 +pdNw7zVwwXnBN/af941DLi8c3Tr23cutyyCOVMLgjUhcAV+LKzJIfVd8Hw+8IPYN
  27.234 +OSmIbmGb1q2VA5gEWl0xtQEIAK9/miPAeUsAhHqOJHd5oXMMKNy4cvkoIOnCFdYe
  27.235 +N4wFe6rW+A0eOhH4DaXfEjAcVVwmTXAp69s9vug6C55vloDo9FCIIA1dWZ8qaAky
  27.236 +Z3Rvby6yrUA6jXiTXbqzNH0XkLHyXnHUqy2xOpimNMhnqtEhxuENcpBTsjlT+CJD
  27.237 +JVtyKZ+fJ9Ug/52GUvK/+a1xcH3O6kNGFZg9VvUKmHMoFKdivmFkPhmiFzg0rOT4
  27.238 +FmIiQfNBBaHavjp9eHUz+R9S2MUU1iAMFcBNQttxrsm8bgtwgL6T5Rgu7Q+SnOtc
  27.239 +3CzUUBbmSsmVQnSqQrNvCeOTXIt00tBSZx+1XvbUyBzP3JkAEQEAAQAH/RQwNpgU
  27.240 +RR+2oIbEoTdJO6RTasPxR/CXiCm71O07rqIh41cEwaYoqv90LIW/QoVcTQl7sn7L
  27.241 +o8ElujdWrg18wrBzm99DuYQwD+Y6Z5tfO/1t8DlL/pgb5DhRo3+dq9UUB+YgfnLT
  27.242 +xxlLgPUccYf4PPMv0oQDGwG1TxQ/L5Upaju5lnIduCDqxZ7dsRaHLJYUC/iqtbDS
  27.243 +JmpJfirGAub4G3hjIZSZKuwEQG9wt94djbNGbHmKQoINPpcEgK9P3duiL99q9gXI
  27.244 +PjVfL+9Rw+PWe7302zvU7JCIDmZ5+kyfI/klhRivcY7hljAPoG3HG45znds8mnUI
  27.245 +V6iQcQkCUofoC10EAMmI5KzYA2pLVlL2BxCFH94XNlxhUu2yEHWQERo3OzAN9HEu
  27.246 +caNxLPN1t7cRCa5O43yQvf9+3aww1nVfSgEv4DT+s0u9JBonGI36QFKG7JMH9TE+
  27.247 +a99Mx2aTMppcEueO6HOAbZchWL8gTihT1/Y2W+xDHFmfwRRSUegO72Fr6XAfBADe
  27.248 +7WXAAE+VVVW6O4iNboUMc3nyccvKvasDroTUJTU9adZHO1fyiCinWkUF5SIPn6b1
  27.249 +eAP0xjFxpqpQ4wcqYMs/6+isa3RK3dpfBQ+zv0Ay4PYXe4hpk/dEQIfH7hTLApYc
  27.250 +07YNql7oqyAnF+xUuAJJK11oU1igS3dx1Lt66+W8RwP8DIM0cqYtrOn5Bq0LSlDe
  27.251 +Ml7stkiuCywU/Gw7T3apmqtHZb00aj4piRHjWQQPzFlCDTmgRQX0jkoUlGXK+t18
  27.252 +a8JBJbh8zmFHGTUTkzsrfHSFS2IPKzfBlick1Eh9vVdMGjd/3YsFFcIVGJntZ2LO
  27.253 +ZY6kfCFYr8hL5iEzba0Q68otcrQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVz
  27.254 +dC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBCobrRZlujMFWKzJpPfP
  27.255 +sNj+NmecBQJaXTG3AhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJ
  27.256 +EPfPsNj+NmecinEH/0+wUlJx7pc0oTXkLmioD4lLlE82TkwSVvHT6MxGMtYxjKY/
  27.257 +s0MiCX79pNyXrCCbA24mA67t1XPQpoEPRVknEEAlfCSS55Qa9k//KuMugFC3HvaR
  27.258 +xy7b8I6MUzLeTJXiF7jGdkhcoinrEt77tTncJIK7WBHNRgP7QUcA5I52vU1LbmzF
  27.259 +D5PuUoaQU/BWDfxf5sLTdpIIyDXm+n8sGnyvIgadbbFTmOLwU9EmuMrg9F38grAj
  27.260 +RczL5QUsoMATeEAfpsQFQZglUqe41uyyLy9uugj62w5QjYgaJdURLXH1FYyhM/zf
  27.261 +JUyEYxuMxLTlG+gShARRGD5eMnuuAstdlEqp1ludA5gEWl0xtwEIANQPXF56qCUb
  27.262 +8dqxvDXf2p/kcWQLJCkRP/6xyNIRty8Db2FEZ3ADG+QpZU5yC3yJ3ixoJkoFa3mo
  27.263 ++UK2dLq6nx1FC816JnSnsKlu7psomaaqNpnEUZiX+46oSh3B+hOAS0m2W6FURb4b
  27.264 +hE6TD4XTWnABa24z2WGiugRpx0GZjUDd0CEbShC/fX3d1+Bj/OPfXR7Z/YD+rglr
  27.265 +nfaauUMB+u1yinMOxnwob4Q+5gxUGS7+hZ4+is5SYGPCsN3KKxUdlNip9F2lyErt
  27.266 +ZeBmhNKACZ83RQvJ53ayY9Fs70Q7srY/R/MVoi3B+aTG1RD9AKBaldFwj8dhcxES
  27.267 +gNYZaFZmKBUAEQEAAQAH/jkOpwJOy2Ysti7rKqJuSFNEMpRCASlBmG/towSOurSe
  27.268 +Hn5T2ucDFyKVVso8GkYYjFxza3X4LlpOMj8We6LwaraD6PCRAL7bjceQ7wd1bZ4v
  27.269 +50AJWBEQN6HDOyn1ktVjbB55v/7Q/3Du03MW05Lk8sz3PNIqhj9ketuMII5Qg/aj
  27.270 +GlCKligClvcEK3rqEm4riTafXoc3KGZZbmuGewTzXRe9/VM4FGohaaML/AJ77Oh3
  27.271 +MCE5Dp5EzdPBjqF/JBddj2ClmD30wIQw+miOE/I73qjIsHaK6FuSv5AADcJiKg1g
  27.272 +7Zj7ihxr1LrK1m7QczX7pKjqYGBmoftJWSpHqkv7KQMEANiN/n+gvpCyiD58Lof0
  27.273 +GBvLspPsc2zPZOCridmUpdDk6yVgSA+4iXM79a4pPqKL2JzCypGB6jdCHweD5ACl
  27.274 +ktngJZE+nzzAX4SrGooitg3WbYPw1xSEaw2yUUe4UIXIzMulLzqaYhsXACHQ17pl
  27.275 +sgIGGVZ0Vkn1Z9P5+swLz1ffBAD6r8eCnc+fcRjOTOguQMun4Fw/csP7Q+LprMH9
  27.276 +kwR0QusaLEGiZlxukTbq80eHmlsskdSXnE6MwlMAjTrrZjRrGvB1n5hxPFqjOyth
  27.277 +JESlamNe/Y8f02esQmgLIekfRdxsJbK7+50Ab8YsngqTYLgWaQhjTk+G1heu2M/d
  27.278 +X2TOiwQAyqdz1j4KUTS8b/yo96g7ozzrtZCYX4QmIbcw+S1GaH9kfalIqDiApsWO
  27.279 +XpyrBJdoanbsV52+2P8kRr/XOQA3AwsmPmE1Q8Cin9CzA1eMYXzE5smo1Z6nyUdu
  27.280 +pQEiKZ3tjALyy4QqicLsYtjEOLtQAcnXT1H0uIPF2f5dRUTNzr0/FokBPAQYAQgA
  27.281 +JhYhBCobrRZlujMFWKzJpPfPsNj+NmecBQJaXTG3AhsMBQkB4TOAAAoJEPfPsNj+
  27.282 +Nmec5l0H/j4EZBHzz/cI6fPzZqYegoPZ6rdHOu0XGXo0HfuNX4p3qv8QCQi6GVQQ
  27.283 +pi09W9sAiF2M2Ual9qC3kuo8nq7Kbuse6NBIxDeW2F5jamyk+Ffs+GI3qrwMzD1a
  27.284 +ZI4S9wiPv3Wq7d0zr/4Fe4AFSA8kQY57y5BTN6QLXPN1srIxfX/2rAleIOp1Op3r
  27.285 +H+0bmt/6xhGsGVGcCGpuQQaW5w8FEUQ8TKi8iGHTE/l4oT8taZVHvJPmUSwZGL+S
  27.286 +yf1z1D2e3kK8eKjlji/xmCQ8Q3OG/9/yRFThKzf8S1vGRit4eVXEK/xXXJIgvVyp
  27.287 +MKStK1jEEkjA9HNdFj3/yovCtNrg+ACVA5gEWl0xyQEIAMOBGlyKbQxEoIGta+Ja
  27.288 +TdMYXXrt+HVJo2qatQCJbXqIJQauUZdP1BuUflMbkkAdRPC4XS9JMzGSc/nznYL0
  27.289 +I1rjI4xwRWSJyatD196RF1E9NUw5i6ptX5JRwJp9PFZaVIxQghAMT86cJjbkYYG9
  27.290 +/5sg7I4xBrxJfyewbFum0u1BAVgSa1I1faFcE/Z2gMESaHP03h/SHhqGigambJkC
  27.291 +0KY3q/wjCNF0QHCCb1e9CRzfiJLdqOprmVhS58M8JNjJ2EXvVusc9d0v/7oVVWDy
  27.292 +V6COK6sMSdhMGXz3uPTuA61tR0ufQaxYiGtpI4krugSbTKmnr/AZiVXADgZ70zHc
  27.293 +jtsAEQEAAQAH/RDPA8SbEV8YDP8fn7WGJnsuW0zBzJyagfzpyjZ+mk89PCAdhd3o
  27.294 +uu3+gvhQPlXAbnhbBLmXcia78B64WrCzBTfzBjZn3LKuw6XNUnAyfa4gmt/jC4AF
  27.295 +B7RQm3egEG6RztBPIUkriQNuTdbNJRj+v4At53vq+SitEcw7kRI1y8+I1aj93a+s
  27.296 +ZgfXoYhSBDzUR9o8gwjj/Da0Z+HYqEnxYhfwohCmjFvITb1JMCqqY5jc1GadYmrb
  27.297 +t8MQ0ab1RuJCUwzA6y5X6b6WP1emKEZZ5Sl5ufqcUJDO4aCfjCAtQYtSaGAoMFkS
  27.298 +YihdlN0eSWK8uBqOdgOvONRFu/GlXtP7oKEEAM9H/T8FMASIDQaHlgnOolEfInyi
  27.299 +ztz7sunfnF6/sLKIH7IoBymq8t7u62Q35LRt8IpkIoFxq9/fdsdLjjLH+666zdkV
  27.300 +UxrylYd+1Bl8YpCmIRs4t60rlJQNUCTQsmE9ZDYw67hsC9Rtl4QJeX6OEevzhvu8
  27.301 +3ZQYa7S+rjwuHtKrBADxdIDbLWxLJ5J3y5mXFau25daaWAK9pAJ+1paXmCpvLwHi
  27.302 +x+VOOHCS8o8wrWZfGCgQTKd/h3Hw+Xld96j0fqUod7tsZ2q/5abJDavcZUa7rPnX
  27.303 +nLBC/gggu4CnTL4KotBsxc5GCLN9nBy23YTP6V6oxlS6BvZLRwItRkDOWtW0kQQA
  27.304 +rDmzgZDPQp6VpYd/sRdSV1WosbkBt/6+gYPh6pDnBtBVDohndQtUUDdQ6IesKV3y
  27.305 +hgNSmpVX61Kp0X969dK67y8BX31DpFmwRTnaCJSMBLbusSUawl5sooOApePowPUx
  27.306 +Io7hk66V+2aFSoWMrqRNkteo1c2Sk/Und8GBD1exWnpKHLQxcEVwIFRlc3QgUmVj
  27.307 +aXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYh
  27.308 +BNR2FlbOV/s6/YTeywTsh7QHSqG5BQJaXTHLAhsDBQkB4TOABQsJCAcCBhUICQoL
  27.309 +AgQWAgMBAh4BAheAAAoJEATsh7QHSqG5UMQH/RgusteCnkvO6tv2ksz1Uc3Im5aR
  27.310 +poTdF/vx5R2MRvf6pbPx4HG7clWiJrAw53xC3Jw0+LeuqKs7/hPitwgTmGtdicVT
  27.311 +irw7GIXv51gnzPud+43ETT/e1ZR8xCc+ZlnlzfYrRCFkOkwdu4SxFAWww8QOE3fx
  27.312 +bkrL9OFErAB2Y2Tvcwzu2nFfQblWURaKC0IRrd4FgU4MCRzcCfHY0MHLNG98bpnT
  27.313 +yPkMpJ2s5dodpP8+l1rlNN4LsXEc77fd15tdRWIVTILbZy4DnsIKpb6yzrJxHnZK
  27.314 +LQZJvGSJdOR2dTQN8XdB1kfRSJ2S3MqE5taMISf8jziGgYS3R5OBBeKIzCOdA5gE
  27.315 +Wl0xywEIALUENfsslNFdAAK/1d+nnAM2nox9ZNczDyj3kjy3i1wHdsrKQxEh4zY+
  27.316 +DpuGwjil9Y52JdzQBZTA5Jp13BUEwCpTmBUBEbkR24MLCo4U7o2bzS/bPbmJuCDv
  27.317 +B8rU+mLPGzaqafaW/Wgvv3qNV22j5WzRAGTJ4tmYWKXC4kIK9ovF489D0965Eg3e
  27.318 +5BWr9t+t7v3XYaULYlbadj0ZxxHOgyqYheHPCGxrN6r5y7sbAwz2aeEV2GcngBRT
  27.319 +NYiSKMoLYc+Pt86OmRtDJhp+hXxJLdslEMW92QJPVgLBLszBHIHjO879UkKfvcc9
  27.320 +hlai5niLqIImxDIg1fBoNmJznsWzvbMAEQEAAQAH/iwpOVQsRagoJKsHCxHzzZt5
  27.321 +FUgYBWR85+tqLqqSarTKe2Aw5RjGaCyhCiZGQ5bXYiddypHqzBnEz2ChdU5JaOpK
  27.322 +l5U0PBMm+KMpK+uKzsIMawwMVCwyHZInToLc37MAbNayz4QhxPPIhlHLLrOoYv3f
  27.323 +pVVxbV8BjErwVwueqhRiCzR9BZehktTewhDQRv3HXhGIBrFUObtSFC/+JZs3jfJ+
  27.324 +rxDWa49AHK/Be3KrGwOzteraqRWSSic31RmFKOG6SZAKlcrt0XlE71jjiK+ssqRD
  27.325 +8AmYUtXtqYm/WyEPJwdDywpf0N7nBalSay190vylbVdIIDjZTDU+OJZXMFfXb2UE
  27.326 +AM3ijs87P9QWgd0L7YPaeaHBGvzmEbnoQt6Xd9UfmzFVUsx8RKhGnF0fSIap58ag
  27.327 +TiZMYEbv6+lV2MEGUTSEIJ2lRWCyHyO+EYwqnqpPBu+ImjS2mrlglBbemybjUxrB
  27.328 +nXF3nhhQlqlgnrFPCTFSs34bodqFgCRsEiDLnFuULaEPBADhFADzj1IJ2YZGL7GY
  27.329 +XcQmy5TA4vRTO+knpTYAfqadq7p4nR3gD5bcyhYrymV6KvuDj9UesQlNFT6z/SFA
  27.330 +wwtWR+ziPit7r+suS2HSA86MF0ZJFLo5q6J0D4kScuJOFlZbf7s1Yv2IzIxlGDyB
  27.331 +RWFkeIpppY7tgN70E355yMGRHQQAyS1O0yke2WOgGPv4fcJpzOGeMsujJGoWn4C6
  27.332 +LZMeptC/Q1idCCgMGr4gxfwFMjo9eVUnfsXAnFU+kTktEM4puxlWjbMMKR307YJY
  27.333 +pNsN1PL9G3eaMGrhb4TIbG6MiK529GvihogSQR7VUk2yPRzYy5e0obYqa9Yt3uyJ
  27.334 +OcHy/ocyvYkBPAQYAQgAJhYhBNR2FlbOV/s6/YTeywTsh7QHSqG5BQJaXTHLAhsM
  27.335 +BQkB4TOAAAoJEATsh7QHSqG51zAH/0I5IqtOPdSm7TTK2pcBkVPJXuaNR+HXMsH3
  27.336 +qWZzG+M5obqSeHwiH7+k1ygrxDpIwjnWkcLYE8E2vK1iP7xtj/d5+VdcQ17bIFIp
  27.337 +QLtmW249tUoiAVe049MNnRSts4ysTNIZqjaHreiTRUk/1G8amBbxnS743sD9bXzn
  27.338 +nWs0znK6DbZ2yon2k5igDIGdsC6TYSn6vx3v3H9aGKMX/O458s1St3NDyVNfKY1M
  27.339 +GEMHw21PLPUNQgs1GmCIMKwG+LoolpBKKDglhffZAOFl7UPN3PBjYGwgqBXHqW6O
  27.340 +g6Rro1Rr9QdERbki3TzE0UBXCISaRRR4msyesxFqsukQSVAe4H+VA5gEWl0zNQEI
  27.341 +ANBWOIhVaTRhZ199H1O4uJTDCMGJzLywJTh0IhnS5HguQe/bo75eCZO6z7mTQTrG
  27.342 +9NN7A+fETcK8F5eRgY7fJ0Oze8cKIMLfNorzWKKRhkOpIMmbIYx7I+gobgcmvxy2
  27.343 +OdMFcHfDb74x2nxW6XJNhl3ZfjPk8Hd2qPHV3VJwwuFAmXo+zjbvAbVXbLE7UxCn
  27.344 +z1Qv5XBYReOKkpQq6Q8vFnQ4lln6fAvotijvCVHirMJO2VkPMdU+1dy57+aG/M71
  27.345 +GPjn3SOHSviq5PHxF3p+N3uLe4H0Eho9RnAnfv1OrXTw8oTRgWxUXl+n5/ofUxPF
  27.346 +4xTV3rLGFhCW/d0w0nD5WwsAEQEAAQAH/RNqtcIfE7sKCPRhWPYYlTtoIfzHtwku
  27.347 +8YkdacA2Y4y/4u1T7yLi6MmX85w8GSw9NrwvDuIe7ZBkr1409Xo3WhV5OOQIEZ2X
  27.348 +6CFzJKOiJH1R2fhwOOQ65dHRUs/f0JgAc8szCpRe5p83TkGgaAl7KDa++oAjqjW4
  27.349 +HW7Mm9//Gmqby6LF3eEj2PiMX91ekBV2z8pjyZLkBoNjaGMhzqHh9SDfWM8GvaWp
  27.350 +r+ZWk71a5Ml7tIBYVSkYXk2JdbpttAoUTw0wWe7nukDhibWlGnhivT7DzAAMIz52
  27.351 +MOuYLS0HTFpqk2lrNOS7WS1RF5XtevHPFpFNU0ykIn7t7BRjmEw5twEEAOGTuOs6
  27.352 +UWLaXfWhCmZTdrMV+7mBbULvnsYkiSiKr38A4/G+8e5cM/77LK+zQwXJqvL0CQXb
  27.353 +QzaOKE5R4Ijx/ef9v9yGYrWToj16XLDIIdtUd74szF+pKYgwVrqkc49M/T/m7eNF
  27.354 +ZLYYYErVLcnZNmhStgvZ2pMQotA9x7hX9T+hBADsb0L3pjQ/nTknhkgqxJ1b5jSt
  27.355 +FBGt+rbUtkmpkAqdMxnlN/jEJ8U/TwR7/ZH7nkG9/TblAEobdHetJzMBtAtt8Uo9
  27.356 +VXy356QftKdXNeofZpKIsoefOITuoAAC/0++W0wjx7EO+4FDqUJg/9kwvWi8oMRD
  27.357 +FvlLjBdCJYsbHHPLKwP9EJvKiTYAF3kF3gyqBCCviMblkbTf8whAMlZBeZmwM6Jq
  27.358 +ZIIkcIhtaABPRUDW5QyEo8QmOXrbiqs2Oq8Z8R2aM84ft6KMdCxMpMPAOrDT4XZe
  27.359 +qq+oGp6p4/cbVmIvwYFJopb8wNaWQk2ycI8eyeogn3HRG1pyHvupXZg/hRRnxfZA
  27.360 +fLQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYu
  27.361 +b3JnPokBVAQTAQgAPhYhBM7YCWrhIhaAwoSH/fd6hr7BO/PYBQJaXTM3AhsDBQkB
  27.362 +4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEPd6hr7BO/PYXn4IAIIMMeSe
  27.363 +jxp0LSfLcUSbCDLqWf4kv2650pikN2YSWe8ZoCrR5tlO0cWapalJWpTA9gnEpxcg
  27.364 +tHGUNO4tFYoeaChVPs8sFxlO4lbDNfE0elUnDpo9Ct9aKQRhO1f713igWRN1KKrV
  27.365 +Nh5AZXpOVpYMo5jCQMX26S09JzKWs6kf6M4oszfyqTQ3wraqnq2E7NTm5mDTpYw2
  27.366 +aM+XwNPrIrqyLCHt1kqpBXHfF7wnSu8/QhOfnKCRpspwRrkqimXuGb2fbaYR/ySS
  27.367 +7PaaG9wjQrLmZB0ZAq+IxUXMkIzkOpOxzm2HUmqps2pl6PqaFK7annR+oocDsl07
  27.368 +tSJnB6rLAHHOCnadA5gEWl0zNwEIAN/DrhSP5Gq4L+EjvWXdq08CevJbb4k6vDqk
  27.369 +Ig4PiIP0Tj5o2y+sP0NJsO2CPhus1El0KdD98J06c1K6leJKMFSQVWXLbm055QXB
  27.370 +Zi4HEaCd8Y26Otv63t9UCXaiEpUqAFuPr4GOY7GruyAkDA+DgYW77E2pPkXJLxsJ
  27.371 +tFoEcQ2hRSqBZ8a/56f+ZrbIpdsvPG9CGVyXvrSLnYqWaixlKJZNx2lQRNo3pOgF
  27.372 +/GkVMSOIpyxf9ERuZnsjJ9eIslj+oxcrNEfAWtqYNGO4NZlPf+hxl/tjp80bY8OX
  27.373 +R9Xhiy7F59H/TY7hWRfsZFivOr2Fv1OWhwAWpVxFHSe0hkqDesMAEQEAAQAH/27T
  27.374 +UQXYGq6MmRIuDGFGf9E7Dj+4764NDCsTHdbO9LM+Lf6VGnIrIo4mEl4gErjMSbwz
  27.375 +r35WN3T3/SQtS4zvZ66KafFn50Jr2TWXiw8i6yUc9QVYBkzrnLUJv0IllYSRb+np
  27.376 +aWiGaHQX9S8/C0YnwN/GqovwVepkcVM35D5tUr0HhMPGUyQTZsT1raQP22lQT06/
  27.377 +hT39MRV1cZwEwqYBs/MmfHkrbNmT/hGV28P4HxpmEbf69wTjl4X8SqXPepaXWmlf
  27.378 +5MWCs7B27ix64RO/bEjj9hxJmKW8GZupFWugETMc/GmDy+f3TGhIbA1t2sxq9gEh
  27.379 +3BWjioQTTwdHzpkPi3EEAOqXMk+GFHGOtUXF6Obm0t1AkgthnpH67+sNHA4IkU3M
  27.380 +tSznZdsAr4hiHhMINukB0hdPufKGs+bXCA1sSTGswrWadSAK6x2WQjhQ/nTz0kK8
  27.381 +AHxJ15az+FlHj047MNJn8uVfynfLLFnIfsWxdtSsb4Xtd29bIHe8iKvasYgCDuXr
  27.382 +BAD0L4wVp5jZenjY75GZW0FSpExROksqgva6Gu+8KBVtK0OB1QlGT7vF8b5ibW7W
  27.383 +9XdnKEk7yCJloirLB2QwcGec8M+95ZewR6a/xFJf+Nt+pd/C0H1Zs77Hw3D67noD
  27.384 +DcXpx6i0pDiUNbflSgmiuPf7jKBRKtQXBfGHPs8JGNNQiQP9HE1RrML2Y+UFSWxv
  27.385 +VUY8/yDJPhVgvUJEMs57SwLJPPnIpD6tJbXQaeKpKJQPPsjhaSpTUVIAHf5HQkFX
  27.386 +kg/eyEvPPdrRlcCchi9YHfXoHn4RQYKJMLZkMKBHwrYTNP2gIf1YfX7taBzxsJXz
  27.387 +rUTSZTO912E/mfJu6nOroHh5qBxAD4kBPAQYAQgAJhYhBM7YCWrhIhaAwoSH/fd6
  27.388 +hr7BO/PYBQJaXTM3AhsMBQkB4TOAAAoJEPd6hr7BO/PYXiQIAK4abIzAL5A7xf9/
  27.389 +oqxteKTpA3K7kR/hgURGexwazPyJpajx1Trm9mxE822CjQcNa8Yi+QyWJoT5cPm9
  27.390 +cOdcnId0mmHe33ihlLzd0Bs7XUwlowYqCOEWhCFlgnwsvSjGHfsqEasznH3HEa8y
  27.391 +tl5mRvXfhaRkK2xvtureWUYwvxBiXryZ05rTqUm3dEGtoJ7ezQJFLrOMy40DNlq6
  27.392 +Ue7rw26MBa1dFw+OSt6eICmEaBym/swsyfQW6N7F5bronRIR/0bncF7C52E02lb0
  27.393 +Yd3M1BrJyj7d+d2ZHi4xArBJlKmCVBKnx7nnrcRGlt5RjSESIP0Nft/Tfar7Mcqq
  27.394 +0sSmyM+VA5gEWl0zWgEIAOEUgefeUVbPA1GrMuDrEO3dSSx1L3i3feZSEVnMZrVa
  27.395 +s4ut6Z/bQbnZpzMRIvb7TG9Rz6c0Paw8e2ilyLNUzeAF1Mkx5yvFFe1eQmeDZh2/
  27.396 +uwvvsYbXPw0H5FjYn25yXI/MaFWicg1KnOSU16gcbugw84+L3tKPdRVEYzBkG6nF
  27.397 +M0F61P7LAM/RAWbS8CpYH76EhIuFsvsUNFPw6Ne+2pYso3oDa6uBT1UcWLXLlGzs
  27.398 +b3x3HL1MNymRXAIBCmnvhAWEyAyAvrxNi0CMRLOrWuNI6yk7ORlvbxrhqRKab/WF
  27.399 +I9hglllu5R07kkLEmxxwGk2cSAYD8RT6aeR5SwC56hsAEQEAAQAH/1bUhPrwyps9
  27.400 +GFAwxdt8A5dn1ztF5+7fhrvMLDJixrqux3YavPZ07MmoPDbYpQ73yjhlrMCZyDMC
  27.401 +UC+CSUdZb2S9iyWk0UQS748XXnG1gLb4SM3lhax5rDK4OTDHPNYsWyYEWrmyheI3
  27.402 +xwftnbaWZXjAra1Sbb74Jdhy/frkm8Flfv/28m82DFUxAx8fMapodhGq7IhSs7y0
  27.403 +6EAOvhRTCyKTnx7bQKuS2MBEg71svdUWU/SV92fntBGzPoPNu7zGqjdmBPdgfAsH
  27.404 +UvhBsDiRZkckfHvozVXhA2AgafSY9RgRDWezaHEif3YTGb6kzCZL5RtHAd9LmMT6
  27.405 +iQFvDBT9+KkEAOHczjHRsZAtceN9o4M3KYBqLw/fDOIV4hqU0j25mEoA3eSvcT6u
  27.406 ++MFkz+81kZhlnRxizBno2qwMWF4JeRlZ8ybWgxMR5DLg/1fB4kJX4wfJXaptrEl+
  27.407 +Ofrg8WtzOX/6SXFkMKmO/oHt6i0cyLml7wBLbHTKOBTDrZN1dMmwUJCJBAD/HPnF
  27.408 +IXXPZauWTXxuyrBKcgRbor5y8i4oN2Q60wxHeGLnP47lD6fIlG50SQWjP8s17ek+
  27.409 +Motk78adzC2v1qKv1o1hbcPij9dC0vfUYCu1cMIhsE0FYSfC+08M/o4QsRt+Mr9a
  27.410 +NRZZjLNTlUTILF6RvJpIsod6EsgfLmP6pLtUgwP/Zy986pz3HOE0nWyI7FjRXAAX
  27.411 +9EOR/8LTVWc/qwdodVJVjgxvFC/tx64W0RhwTeTqL90uUrW1OF/ZaCsPXYXgc/3m
  27.412 +YC9U71mEO8mVh5S71mSgK8lrPTEH8xcTuzOnpg3Zo2pgfJyp4Qgs7iEBSVWlJVC9
  27.413 +sp0i2hXHZcsZntqctWpFG7QxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5y
  27.414 +ZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBBQtOSjaIe8CoootThz1+OCQ
  27.415 +9a7BBQJaXTNcAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEBz1
  27.416 ++OCQ9a7BcNoH/0UZFWkdZbMtQE9dJbECMEO7gDJhqudKiYoRPgi+7a0FBSk3QVG+
  27.417 +Prj10fFlhMFbQ3gSBjHCfAgWEIyJE+ee38vL98vPqJyC6isu18fjtptYsK/+rN9g
  27.418 +AHbOR7Kbfh9kkMuyZjB0mcAUPEHMig0hASZ3O8umtJZwnW2uwFGR1TOfJBrWkUZ6
  27.419 +vA2y60Q7Yir+gKucF6wa9Bc2EVwLyuIj56tNNlsfHsaWfU3A704lqzgxKjqkJ3S/
  27.420 +Zvcw7aRFJ0WMj1Vda3zkQz3lZxHRcEYqGukyEUXOxbEH5e1yDCeL7tsM7cJcyQ+D
  27.421 +2tdDrB5Uk/4lNe+4wZc7ZDc2bgTnPKCSStmdA5gEWl0zXAEIAOdDlt6GC4zlwjrU
  27.422 +SgmJJIaViehxFFCamo+b/Y3Kff4IqcCJJe8k4gal6J8b8ezDpQXFuN/30gn1vBx5
  27.423 +YlvmJDF2/Qo4Rd0eYzhPTkGyg1HBUlMuowhRtECmfnhq7aY/bLPxsPuxNfVA0vtZ
  27.424 +9FxPduqj/+32lQ/uBV536KElFtrNkotsFQLu+9UTakts7cbT2i8ZrWQG8xlqONTR
  27.425 +5xfqjZXeJ2f9i4DKN6ojcRvKWnqPBU/vWuk23CApFP3LuLCi5xdHfitf1kya+Shk
  27.426 +Q+5ycTqXThBe/NA6+h5vFY6PntTT1GVcaEnNFK4uat1ey4xRSNcvFKLJN/aBkzPn
  27.427 +0M70NcEAEQEAAQAH+gJVnHOMf8KZTExUJFdZDOyLsc0OEiiiTOKGTl6KFMWVuw1E
  27.428 +XSTfNuW0CEd4jIjpgdQ6IRdSrN+N8qszaaP4QbUwSIDb8qRBzaTYfmzbmKeAkkcL
  27.429 +GBkfW637jZiD1M202MaED1d/vBCTafsgoZ61FyP/yeIyLGJGfUOikHoK8gJ9TpPF
  27.430 +Wzi6yYySx7CltRl2rujTAkDM7KUVv6qgCV6SNNyZkydU0m0732DNfoqvJBlShLzo
  27.431 +iqgsUb8LwcvotYXQYW+bM0jqAX1/uu1eMEPNOLGE2M4IbiT3ttJ7IojnD+RGqyfF
  27.432 +1L1wEKSLJ93D0Q6i4G6zEd1UBdEegiuSz97wKqEEAPAA8KvtMXiDQPRBaodwyS9k
  27.433 +UboeV4beExLtHKIbIh13rJyuN6JJPoVcIFtSwI8ijiQx92WYxC8budG4gOym8qp9
  27.434 +awdb/Vi6KunzBXc2spLLVjVvSaQ8ds7EleUUGUGCTYhPwduYszVnlIEHmAqnkqbm
  27.435 +iERaAZh1/FoEt0p9HT3RBAD2rYds/GPWJ2bP+XD+xTACz1PPzw6fpcBXFWfHpYHC
  27.436 +qrjijpIBQJaZ8CfPqF1qnT4cZqC38aoXwvx5C1cspMYVrtFlmAP15zqa1hCxNs/A
  27.437 +vOyDfzZ14bdBOFwDVToXmbylNUKjCEcynFiEbhOzi4YwNFbQY2VKmlaDXwUj+snE
  27.438 +8QP/SQ4Y95i4AYJ9HrU196ClSgTULVYObbljFU/J/9SJUI7/xMNVAg+EDIsm8Kzs
  27.439 +kXOGs2v5+VzxbPEwCl/S9hPJStsEEEr0ZJSFNwkrUqPxuIUjUxYl2kGsrqlPId2r
  27.440 +rGcxgvMzsj+co3JcCESssGuT7V+oDv3rjIqec1AKny0vboU/a4kBPAQYAQgAJhYh
  27.441 +BBQtOSjaIe8CoootThz1+OCQ9a7BBQJaXTNcAhsMBQkB4TOAAAoJEBz1+OCQ9a7B
  27.442 +Nz8H/RxEq4NR8WOB/sbs4+qN4aqKlb+zH2EyHMtXO0GJbrQZCYnUfQWf1NVF78zT
  27.443 +Xe7NS0vWAd8phIxWZU01UfF2uPc5AY/V2FpgkeMoR+1kMm4L9wP5rdWSKEnx78gh
  27.444 +o4J3uKYbJL27pHRIPLswrJy2aWiUUK2jSWbWZV3fOzzTywrNOYGzWQxag2Nbhmje
  27.445 +HdumD0wwXD4RNviunN3cgNrpRv1wHoIvxpUfYHfbyB9mjnmDDJGPh5mWWa2fDlfZ
  27.446 +uXP4/8HZbhScWj9a4HXpo58ULqtU5Cn3DHs5HQbsm+MEM85BRHEFRYhkbU3U2kGF
  27.447 +oEPWX+59d1doeLV3dEnxolEAaCKVA5gEWl0zwAEIALf35c+3WYsMK/ZioVHECQIp
  27.448 +ZBXgXewPczKnPwY+ucQ2cBPdJpbNPmFSPoisuEgogl/Z/kGxJJBhjNvn08W8S9EM
  27.449 +UeQZTBMR6WOLE8ma1hyDgJGWlAUoCBh7VHvxquFMN/CIANwDc9ejVhh6Ng89ubhD
  27.450 +zvA5cggUaJrjJRDS17lCqtZwXZfGT+NPK4Ai0fjSSFRHOgzX/u1LM3Qw2oE0ex+g
  27.451 +9Lwdk4+y+/y+MqPwsUtKiYiAcMKRC+RaKTwjAVIocRCzFu7oJhN7+67HarvnxIGe
  27.452 +mRcf2RJvcpbcbzoSXdpOlCBX2GWgNIUgGNk9h/ONVu75braSkbaMNz13GtD1eDEA
  27.453 +EQEAAQAH/1Nn3DSSw1GDqLDRYaMQ9iaZPmuep+Zc0NUPt0atDIrVRXX0B0lKbzQv
  27.454 +VfOgHwJz/zvWuOvulI2y9GpEziHxbwwtgjkgcPmaXs5HISb/gIA37IPVGXHHBviW
  27.455 +faSd2ePAKwJtnrohBJWo02FQkw7Q5NESSRFncfgQzKYgQk9A0BYIyvWvKUoXLXJ4
  27.456 +I/okUG9q6QFHXiQ5yWNWj9OcBpWmlcbD7cClybpoHtRtAWvqhq+TZlxqGDayQ6v5
  27.457 +S1Nhemi1MzqYNNCYb1Uf/qPJuzPiEZ+MdvI7/lKhlZLg1GcCbtzUtWIrtBuGai79
  27.458 +ovzw9NgG+WiWnE9cd046CchpIOC2h3MEAMsTxuZ42KLV6DbrwHeawrbRpbhoPPBe
  27.459 +a6GfXx0plwGyVQSh1ife9QkMs9nEdo4w8NUCVhZfavWbyrEKRV+JkwBEaHKcgC5Z
  27.460 +EePndASgrJybxpqtbULwAQZumq2pBlIRfy4WQ6YYYUVuyS87atmaav1mSKGv1Mjc
  27.461 +634mFzezMnQvBADn6UcEFEDsKZ5VpfQtLehqAlC6jNtIe1MDQP9eJd6ol3g+ufYi
  27.462 +j64FO65L0g7rggiPp2fuCRdb+s+Rufxbq4aTDWO7b45OBS4vKf8HF/EX75Q1TrEL
  27.463 +MYFy7f84wY075cw4xtpBpz9S/DNNn/o4pX+c9iJLc7ebBCK+2fp4oR7hnwP+MEiV
  27.464 +tXy79HXDLWNogDCGaG+RwH22mRxJo4D3kDXjBYsfJ7bYIhFiY/mUmPGQWfgdTsE7
  27.465 +XZdqKe+XWZrKKcGOy8aYltRiOCHWb7Jy7qMv6tpcXTKDbJ8BNAP9JamMdzxcPI3O
  27.466 +9ox0AkryacfRwh3SZ5SkiJSrCvrp4J6c4mySiZ1CurQxcEVwIFRlc3QgUmVjaXBp
  27.467 +ZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBP6r
  27.468 +o2FethX+1KdyLHt9pda7H4GOBQJaXTPDAhsDBQkB4TOABQsJCAcCBhUICQoLAgQW
  27.469 +AgMBAh4BAheAAAoJEHt9pda7H4GOEF8IAIxGAcvbollx6NGEdleQ2uJlHu0hL9j/
  27.470 +LckV3Op7pP9YEwdA43GwQ7IazFXLmzOokvzNe7UH12/NA0lL1LhGoxh/jXkERcrt
  27.471 +ejw/skoVcN7CeyUDR8aLAvrgCp78iCdLGQ/imKfT7Qmy7KXTbhncUXv71GeiaVne
  27.472 +V6bv4RiFDcNt1wkOB+V0bYfuK9+EUtBFcJ6fgH+/Zag09ASxNvQERNC9ggV4jtDN
  27.473 +H9oQflGuY1dwna4v1Uk57GdI8NDPKFrIEQhvWeaH92WEUxAczPNkBF2CMLZqmvHR
  27.474 +CmQR6PBEAnM5DYiSkzbSnESV32FdI5BVHwY92J63fvvDL4iikrhvNGSdA5gEWl0z
  27.475 +wgEIALNKpv1ApSjIBp2w+5M1SWwIvDC7lnFZfTiwrYptJR44WMaulERerQVIyW+8
  27.476 +BSPsVkUX3jTRnPJQQgObz0aLnwILmOOb3Y9bnjbZPOAyKvcdKKpo3mYV2Et54/ZA
  27.477 +xhgoEFU3hhi5znHvY+Tdxz34+/C9jx5qpFPt2IiODG2sapAj4FArErXW+SvlGI7i
  27.478 +ewERYT04uQ0k6yxBjs7QTqojD9ZfagYQ6kOAW5zyUOLkY/G8pxOSAp9EBm1YJyI3
  27.479 +mS+7cfyYAtqmZyv5ft5UvjrhclW31bv0eyiE0z+q3yTNTurIzydOAZs+S+IdpdrM
  27.480 +8UnQCE6PvPHb+l+mwU2Aq6auBLMAEQEAAQAH/jKCgn7wWlcd2vdL5+P17CRaZaIZ
  27.481 +Bu4R9vwkkg9gZkeYOjJm9nA4d+f4NH+c6ZnQOBGpArnAn8WIJMDdgUxvgzFRURY2
  27.482 +T/nWJsFu+/5xQ7dwaIdxmc4Ks2+3/Cfg4a3mg4tuZAHNPsLMXUkZzcrAvUF6Nbqs
  27.483 +8nSOmiUGV6wCGddXOy4NyiTUHUa9kerDilAsLIvT2zyiXiWluyAeuACA1LO+9Nq4
  27.484 +K9JCo56Dh0g/wPeIxYFoND3cNCxjTRz2r1nB2KpE6pg7g7c43gfCFv7CJVRFpkIu
  27.485 +QmIicNfzRQRStP0/UVGCEkY8Pov5Ss5+2cV/oIeUn23tQm+CCitw6y4mWCkEAMpG
  27.486 +/xVpze+HmX0mRjVpfqo0CswdU819rUHjBu9CfigAesOEcDP6d9DVCd7KUBkCjIVq
  27.487 +aeL9VV7/Y0wc9ed/phmnMZoVJYeqbf5Tld6w6vj2XJgV8G0ZjYwbeZStISuLC1gn
  27.488 +t1rFrJX3cinpWuZT7yguSEHEMuj8sQKeGAaHUZ/FBADi6NZ2wDYZbD0tgWjbdIOi
  27.489 +Fb/4fm4CBRol4K61HmUJtwh8DfJtn6xEt08RTbYtWuY9xxUpC9909un6Xe4C0rBp
  27.490 +ZoeiD9zp1uvH9/2h1thtHAoUCk/rY5qSsH8lgexDGVqtvfig+o4p/wbY8UUdWvBk
  27.491 +AzN1ipPyFNIkfk8/oCaiFwQAwwnzH8AfOis6FfdS6y+EZ9kzv9q++WUPoXGLiAEo
  27.492 +90z26WJLCu5GnL2yZeZUPzOCbPU8eORK5czxwLR0BFqfwJmCQzClFDhk583vdfbw
  27.493 +7qNue1HR9IRmdwVb851ZqL419BXlx0zx0POI2tVzpIpUzExc+9jM+W3BWYClsjwO
  27.494 +xPVGOYkBPAQYAQgAJhYhBP6ro2FethX+1KdyLHt9pda7H4GOBQJaXTPCAhsMBQkB
  27.495 +4TOAAAoJEHt9pda7H4GOpdYH/2MI62r9RRlkDNcRvp+hLVWVGInXOHiKtm248Q5P
  27.496 +cGhY+Wfkuiywe+7KpHIzVmJjOAjAEB07nYR2mf5a2tRguB6cZ2qfNqnN8atECMyn
  27.497 +cFL/sGrr57kt09lUpSjGW9u4SARIYjGQBtEBkNKcrachjH/ZvnD1WnYoXYQ0ng+q
  27.498 +eMmtg7BDXySvn7Pflf9wbaSvgPdsaQ2N1hCST8N8dgPlxkE80aKT4xa3WKB8BSyr
  27.499 +lOORnUhbpTUo7xsjbNn7EZD09WdJ4wl7dOH/A5aJk3z9CMNmh4tYx8Gm2HCmL63A
  27.500 +Vh1yq12FsWjq/4YcBZy2aGLHDPuwZ/3GHxqrJYZ1RdpJKVKVA5gEWl0z1wEIAMZ+
  27.501 +rxH0qTTNdU2uDaW2CWf8XuBOHr6pbE55T58QETi/G/4JXn39wqt5TcqKe8p+aSqe
  27.502 +alncRFRq20iiVGg2jKPyhlDz5XsPyVu+UZcMa7HqwZjl1mGPzrHibLfNi2TnHCR6
  27.503 +Sxpha+FdsJhk8fkbTRPWgSxeQ0cYDMATFIxMLavk3GJ2uhqjfBKp8zowrOxrX2XY
  27.504 +rpXKFI+d3RstAdIo8sJGvr5OFAZ06vqUzlE3Hey2ux+zRoRp2B+MIZuFwE1Olbkv
  27.505 +sct2yxSVCV6FbeG7Xoo3Y0QeMLhNg6ctBWbo1nFc1SKgc0+LYf56yNUhRIjm6EkO
  27.506 +XgJO/lZp3GGz422K3Y8AEQEAAQAH/RFlA6mNU7tar/IX6SlBm8Rpk3+Q86pzWsLr
  27.507 +vZmrr56rR2Q1OlB3NEqQ7aDCDwQZR3+3yeEdvOfa72QyRDcCZMPEmpcDMJ6JV8ol
  27.508 +klfW0Pnn9SxAI/qBFDTMKgksxuTs8y89KlIMVzG041IPh+bzyLGO2ttiV/9QcQ7v
  27.509 +UnMoWoOVefb88K3hxFQpASyTEij8iojhEgbawbVjEkJ0ztqmchW5wrx+MAlGX2qE
  27.510 +zRMXH3gLdcdwZkzsnk6V08N5C+6rauiWIFmQ2l/sWzyTHWF0dh3XwEGvmn5bCzLE
  27.511 +Iahrh8tAhKP9muW3EmdtyW2v4WuJY6u2jgQ2asRrKqDdlmQTt4kEANIzRtB2ohrq
  27.512 +jbsicO8Dk9QT9szz/6B3XtZWm6UP5XTQShO6CSYDyNTG5QBm4o2myF5/VIM6Jj2D
  27.513 +HWWMPyzFqa3z+F/W/5KjSWhaP8pT9r3RQZcwhZTUVaCPpgjWWkmJkJWkMmuqY4Qj
  27.514 +mfZuKUDoqqY1HprjN904NlnoWfO01C1nBADxvn3dyq0lbgh48+/owhUs3LaJYoTt
  27.515 +0mR/800oGH6y8cN5EwMTo/393nNAvLqhLKNbnPeTml5S2Bjl230Df9P3IE2O7phX
  27.516 +loUWCSrBQJYptZX27E9MPqdlyTeUgpi4AQkXATktOsl3iKEduisoq9Nsi6tHHDBD
  27.517 +Uk/fN7wyhjaNmQP+Njzi1Bu3k+CPKzt2FZ/PjTesB3U93nH+Yct7ViZEJrbfQIVh
  27.518 +EquyIsCH7QV0NTAnvOOsuYls6hzK5JiDa1pMaA8x31El8Im5PYqjKNZE3SfWRHNt
  27.519 +yd5QNH72cB1rDtdxEJ3p3Fhag1uP8a5DjGI1ZdssSmzLSP1qSs0LsGxR5VBCy7Qx
  27.520 +cEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3Jn
  27.521 +PokBVAQTAQgAPhYhBCpmJ9rOPHpXYudMuGO5uXMOOlpNBQJaXTPaAhsDBQkB4TOA
  27.522 +BQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEGO5uXMOOlpNWKUH/ja40aq1nPlk
  27.523 +g6yxNIErVU+q3g8K9YSE+N83rYFjLRb4gz9qRJhDIcmhWrmRNSZcRgWteIFI+L75
  27.524 +iVVfLYQo9NlBfJR6eaFJiMpeUYCmewppv2aj59n739LRyws+TN6n5JG3XiXHo45S
  27.525 +exbqU32xFXFNcJudegawHLKUJ9FYr1tegnkZB+fAGp7CpFeqpIgCwUrfXV2GkJuh
  27.526 +LUtsMx/sx0jBBwvWTI07eR64+wb052vuYgTYN/fNfBNG3lzIVrkFPkDnzm0dWIut
  27.527 +Q7kLiawoO+ArVuGtmwrcFUm1y6bQwQVftgNSdC2Ngbs8otWU+SnvDXrsTMDVkjWw
  27.528 +yZiCAoinTcqdA5gEWl0z2QEIANwbK+RFBR02bWdejNlJvAa1XV37iq+jgdz20hbv
  27.529 +PTpXcyx4H8oYBwksE054iDGl/LdK/kscF1ItvdXSpPEbkxJv7Q4gyouk9+3sr8MF
  27.530 +Xa4FusfEisSUVzSSmYzVY0+GNjUy9fQURryhUQRp31PUetYEmrQ0G2PKohxzvWcl
  27.531 +NEfbK/KUjA+I72o4hA/AXwnaT4QbIAvBbl4YjGpr8w/mhcJ5BQF1ny7aTCgOHx9U
  27.532 +SNTq0q5wxm6wOP+nMpArMthg1rJg/95IdjcGB0dhrIfH4PXGAN9T5Zg+TUY+OMJN
  27.533 +1f2/tT+hBOKhQblcHNKxCPPbS2lRzJ/+BmMhAPbzJbv56o8AEQEAAQAH/0TvV5xL
  27.534 +B5KCINqekLNe9f4N4FuWc/WVWo9HWD4pmH4EtIQpbR9gzhdP0A4kDtep2k/Xs3P3
  27.535 +rNAmlk15BwKidbnxBwgFOhppROMl3VhRfmkJz1lQk3uE0Bkdjuy+Sje2W5TmzIQw
  27.536 +s4TRayvcMr8xDXWpBIDKzwc+h+4sS5YZ31lfVPdQ8swSt9S08w6bA4MiNiYwdUqp
  27.537 +R4d1qmu/3Wv/IPITTvzW1ezPqUagrLtS4a857nnmZVh0TXIZRO9deK+5J9JPXkZn
  27.538 +MvqLLdsURXGAdJUY/IoM1JdvPkQM8NalAC+lSlxVXT6zuXrN4LEqYQIA4l/JlukY
  27.539 +TFcQVwQgECmc5+EEAOKciBFjHtyZL4BHvXnwMLI3SiJrjUn6EMNsebojZwzddebZ
  27.540 +gpsrZwY+zokCrodiqMl07v9QAp3i1C0sMQecC8BSXnAtcJvPCQsLr/QSYTifv4c/
  27.541 +t2iI6u1YI9AyseRFYwQFA9+XfRGNBZu54HSSw+o6CZcRZorvxBqPe05i2wdhBAD4
  27.542 +pqoaQy3gj3VqFaaC3dyCpeRip/XnLhQ/FkBIxx/ET92IIZpj+TQGZ6SoRx7WJ7wM
  27.543 +yAXuXzud3Szu8em+A2304yqPEe2E3Koe4lwfeFbpBd1yHvYTQQ4FImczo9XBYck1
  27.544 +FziOQNVZO0tBG3hxJxpOT93LDC3JX3xt0PbJbUZn7wP+JZb0ljA//VNQoV3yghHm
  27.545 ++yJla4KTVilZWRfOyh6Ys0OgQENgWaHpEAdbdLMcpu7Bmspm0tXSnqTlC3X+vQXO
  27.546 +VR2hwuZ8nHmjRl17zdW9WKkxlEdXo/lTyAkDMY/kbcCGHyp/GOXBC9C6x7ppjLaA
  27.547 +82Ie8BaXWA4RrzVrlKxUbVI0ZIkBPAQYAQgAJhYhBCpmJ9rOPHpXYudMuGO5uXMO
  27.548 +OlpNBQJaXTPZAhsMBQkB4TOAAAoJEGO5uXMOOlpNU8QH+QG2AnqGe0WVCTk7yG+D
  27.549 +zETgBUiua5O7tyzWMpstHgFs0B7f62+AcziMPwxdtvkpU97IvEZIcrSA9otdrk7w
  27.550 +6XoIqzG4nlHs0LZOVOetuA4ohXP/SYeK/Srn5zH8fpj4snVBSvMfp5xoNFobcQMg
  27.551 +XjZnFICTVX/Nq5lz6ovaclcAzgTp+qAk0wmOfFa4t4gOg8uCru6RVKdLei68Sheb
  27.552 +l3T1Ch/gJzjCsEcQjQh7t9fpW8pUcDfJKaCLYjJncyKoNOphRbAZDx2/jPihQMg1
  27.553 +Ok+ZTDPALB+RXU76+LbDu8F/B5uLvTLqhNb9ERJ31gcOoexo/F+L/LKBX0iCbmdx
  27.554 +4FyVA5gEWl01oQEIAM+fiDqAWdm+q77FfAO8Nd6AcJwTJl850VT9ejtTLwkOQ18B
  27.555 +X3fORJko23Fzz5WOsHiNJDce6v2l+0XvmtX/kqPRxH/XhZuzChJXkS5SE86XH+5y
  27.556 +Yq+5XXd7s6X0plBvgYmEDj+zFZgjXEUYUuacKWy+e0kbK7RaQiqSyEFObtTa2vRq
  27.557 +bRc6WAirufsjiG0BwCg3RMB9ffNd8sA0rdDYsTMviJBfck8aap4K/5ROZU/eB4pX
  27.558 +TlwTExbMkK1cyGMAJHZ1O/XA/D5MLkqcIbu2SIpM3vZcX+m4F0pl/8N/OKYLSO4r
  27.559 +u6v8DnhEMg2NpENyGIPHDW/sHQ2sID7Hfyl6m7UAEQEAAQAH/R6cCHuHfLercqqX
  27.560 +duceElsRWIjKEfgsD/6VuDWS1/Zf0fLpwudo05g4+9FIH6yO8tlzBYnS1xY6KEdx
  27.561 +QcSW/0mDnZKzdZE03iFCI7dOhnkIsr52wrHhhDQfWqb24KYvKkvZ2jft8RsS64GM
  27.562 +SnyRPVI46vgmN1VJkUOxjDCEnbZnobBrRE9YYFCDmHG8fsDMM3kka4A089ErJNB8
  27.563 +lPhEiw90B98O32BbDYGqI5nWifAfSq4yETWW8oZqVEbGQ0p2+oKiGZbwI36dtDSB
  27.564 +Dk2gRHbr3vhxpfvoIQQ1bfSXOazntyRNI3G2RAjJBmYt9MyG8XGa84ci1cgWaj0G
  27.565 +2tYHYqkEAOPp26j6/bmHJE8eBqgvnDhcqYO3r68sj7ooAPKJsAFWMzjy9jOC4jW2
  27.566 +prceksfBF6sFn72vebJJ9lH7AbtU0UxqpPKKuxsA1/8dcW8lli33ULdrZ/SvscR3
  27.567 +uEhdPPSGKwMRDgGy2qc5/0S7Gsx/E/ZLrjl5prHjmIoRxwYhO6ebBADpNY+lyH4g
  27.568 +C63dE8ZUGNxGvU1MwVwkJFzEgDaN8rQ69wc+vCBRawXDRZ6KK2H14Fk7QOvvpLMF
  27.569 +1NDf3ctIz2Gi9ZgcPfzcIgaTse3XqYFJfiaM2nped7QOj70vegvWUtEQLu1MoUdn
  27.570 +lhm1Ob7OX/TXVANIl9TXWQV7e6onZwqG7wQAmnznHCW9Z0Wy07OrbtjbsC61n/xz
  27.571 +kulU6ANCE6H3ZYm0l3/9hzulxv4q9j9xElB4WSINtYOuJfs+Tgyo5PG4YN27HbTB
  27.572 +j0Ko7TxFDP8ea1+A3pIeoX757HbOStIbE2AJ+zXRQlAChPIc+ygJe6OjpMb+bVgM
  27.573 +oiPq0Jwwk6aBr0dD8rQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNp
  27.574 +cEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBFTIHdH1N0eSB3th+VgZdUZP+HKf
  27.575 +BQJaXTWjAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEFgZdUZP
  27.576 ++HKfL7UH/2r/d9M8JRuXVG4to0YBF9nhtL2wG7cl/5NHLRQ+91nbqA07/QZziQs7
  27.577 +sq5ot2XKYC3N2NUmIHDE3hMWzM3dG2plN7/xvtaFdNo41HtlnWNb+bMKfj91bybu
  27.578 +++2BCoRfwWtHUwlkjYcXF/AxiA46qj6UmBYEcEPiaiLObgH0TJ+D8Xo64UP3c36g
  27.579 +s6sFK5T068XQ9TYj6YdNA62YOukxoc/0iaVRAeKm7cnUcCpxoRjybeo+6Q/Ncd3y
  27.580 +CN63FY3kxxeHvkYluC3yNWbnMFl7Mmh1GBXx23yVfWscor4IkomX2Ue00ptxut65
  27.581 +reUxlXvDq4UUX2O54DVQMeJUCzpkMG+dA5gEWl01owEIAK+9gJUrodadwHVXDIPo
  27.582 +sjgDyVGSYXWMxb6ajHKZLc1Pb4/K7TNGo0Qo+VtT1TepueC1FHHSWHpjgpV8TJlU
  27.583 +FzcPtPobZ33jLPDIpolojPamXXEkfRp5epQ/0ppR3MYrzRQDS5Z8mS1lpD/A8jrQ
  27.584 +VmCQMXZEJzA/lDP+oX2mHLvA9CRoRUjoIzpvQvAqKe/dLDmpfjfmc2I3W9cpAiQM
  27.585 +7gyGFr3Hbpi5NCde8dqC0Zvv7mGQaPSLYFsW/fXAlhMiBauCZ5XUTyG9dLmIdUW4
  27.586 +TAVu23NKoAdsdQFCmAJX+1nK+cGAw3bPdDGnLCmsFtjWYPEc9JQc4Brvk8bAOpk7
  27.587 +kbUAEQEAAQAH+gLNRqDubHGR27fLoOQO3cY4ln8SQZF4+hD2i0A4zNKWwppy/+DE
  27.588 +59Rc+N+Ev/0omGWsWuGJlC0Sg3LBrfeyehKybIrye+dd4auEkR//clUpUgSkv64t
  27.589 +xUVNII96Z1QwkAGZYx0ZfsQ6IKa0gguGenBjNj6rA3KDjuEZO4YNjR8KVIshB++i
  27.590 +w8BpyJvX6XvaWN8IUF7JA4ua68B6SGvYLtBIKihBfClXqrjqp2vyCdqH/3L0gT9G
  27.591 +eNo64fAEGUyaXrjrbwaCwAkQ9vdliNrFl+Yzewq+ogDZbf3GBVfKK0EJLwYrQY3g
  27.592 +j4zoD3hyT5AI2QhKwqM64HOZeLKXmaR/w9MEAMewyU/tdO7wKlgOpW1A32lHdSVw
  27.593 +TKy/U6CA/fYDlXyG8uRVBSNXEH9jQYC2UWl37p7DD52yoL9O3zrdyNYDWZ7HXBQs
  27.594 +Py7a361zx9kbAMtsPjur9kagdc3ePKqneNzz8ZaSFWO00veJJBN1u+IfUWJESz25
  27.595 +zQiUrNisZC4KP77zBADhS8umWMUuIl6cr6eND771gvH/4eItpTtbVovmxU+2ri43
  27.596 +prX65dYbVst7TDW2HpzX+h8GfKoaWqB+ZN8nKP1uQRdzruJbPvfRiejBYmkdwZgM
  27.597 +OrD9yXDBx6bk274GkAmw0U6LQKViqCf297Q90kY2JdUd0Ou0pH/LMyX6++YmtwP/
  27.598 +RKR3+Gl26+lFTt8Wxf/9UKpHwATLR5Rrs5rbCKOluq87TDFpKlr0gRV7KUvLGwFp
  27.599 +eRXqGOl8Nqxro9/QE8lHhH5a64SvTMvLZ7Z5uKRxEPJ08CU+ylBFHCMdzr3N7W1+
  27.600 +/rX9GY7SG3pPiqivsUbaU8VZgZV8PxyzD2AVRgU45hRLbYkBPAQYAQgAJhYhBFTI
  27.601 +HdH1N0eSB3th+VgZdUZP+HKfBQJaXTWjAhsMBQkB4TOAAAoJEFgZdUZP+HKfjowH
  27.602 +/iczZntv6yCeGn09xWPsLpgafF4r6rLr4FD4q+XRerDvHnHNb87fKVEE7iA0YjR6
  27.603 +ZeRo14Ps0F/fU4nSsBWA7FzPbPiMmW9Ex9NhxXqSEmNt82gmkqsD7jkcjqXzZr+g
  27.604 +FFwOt8nTRAKoHjdVWIyGKPUorigSJqfwsMTPKFjvCEV2F/QyWocpBc5Z5wp1nI9m
  27.605 +rWKdFK4BVhMKCJp2LfDwZEcyexq9XHTx6mpKKT4jOkgr+7/ubfStlYycQdOxrbKA
  27.606 +UmwyJRuVExTYu5vuMQQ8MYS+hfQX1u/wczMHtBIcfGO1EKKIlY6EG1Iza0sXFUvJ
  27.607 +kefytbDzI0SRWnV7G8Qo8l6VA5gEWl01wAEIALPtHDY3PPmF6v2E2S+GwjFQgtc7
  27.608 +EoiZBFE2ohZxM3N7k+sw5bAdwRVtivugTgItp1eK9+VkJBiGtMbf0e2AIMOrZO7R
  27.609 +d2yyud3C/vbsjDZsDpsxqQ+jjzlfaHd6hwIeOKrYNtWEQi1FlBA9FK0ho3t5N1/p
  27.610 +ECRSh0tKhrXr5gGKuAmxJVotaQYhXx0ymLL7e7wNQ2FfMHW6za/ywU3mBcjoNiOX
  27.611 +Du+xwwKOJrdxtMFwxzahOX+nfGs0oUACRurHW549hs+y7N23617F1TPWxd4DL/8M
  27.612 +VVMyopLqJmZnBt0TvzDjY8Rwph11dQFhF3Cvstf0op0vKa7QDuzmcqM9lbcAEQEA
  27.613 +AQAH/Rb0VBoSmAPZcu5fCXpHvfSeqeKdlbK5mtRlnO4yCPddt7RUq6j5Us3SCN4r
  27.614 +SGh8vJGtmAy65uP+I4gPu++J3iQ4dIsHTC4g6xeArhiAey7iQEbKYiAtpLMUGfbM
  27.615 +OfcqNd6N8Qjyc6Lk8ovTzxR7ayjwgQEKcdXAdaREYMVK0DA39Gu91YB0MUZlWm2i
  27.616 +Lc3PFtp2NYfYp3gGQwgceORibsUFGtiTLFDKp+JxKEVu4W4SW3TJut+n4hD5zu7K
  27.617 +EVl8Puv5qpynemDn/w8u6ki0Rp6+ABwrq9fyz4OQPs9Z+dXNGXZlCDxxZJAYDPps
  27.618 +SsAaMHP1RifgOs9a7aTBXy0G/tEEAMXpckIjn4XmV/sGl3hQytT1o0V+XszdTmMR
  27.619 +B6Fe4D26AHgr3P1ZoP8aWt14BntucUoaSCob2Lsr2QdJqZzF4DiF9O0zPxaLHx8H
  27.620 +zlvuxAKVDYCaQH5zUB6IgWoZY68NkxTNSevOsTpi3CfU6Ro3Km1oOJbWfulsnQt6
  27.621 +P3jHWTiZBADovETZxho4KfaeoYiO8mAHRGgX+MvOxPs/1eTBiq0i+xlZDzXkhF50
  27.622 +NFjNaLflfh16gPQ+h8LSfWzPzTnT5AEenijciHS5YGTuiO/GMdvDKXcNWzBUDdKs
  27.623 +BEr2jJ0p83stRHILILd1uegMtSQHQWQvuToZJtlR4Hk4rBeAI4iizwP/X+XZfZBi
  27.624 +iMyROKUO5m310DtWOu0zp2M2RkuDCwkurYBpyc/AA5rG8cxwT7eNL+GkldghuFVb
  27.625 +5PWPF3OCC1dId9ClmKV1YpxaLCnnihZNjYy9DrzTdaQ7QveqSWqCfr7sNCiDYooT
  27.626 +dAOSY1Djn5+QdBNFClm3P6h1D2bUo7piZts/BLQxcEVwIFRlc3QgUmVjaXBpZW50
  27.627 +IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBNRLLWZE
  27.628 +D38Zcro7RZiEXHo3UiiKBQJaXTXDAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMB
  27.629 +Ah4BAheAAAoJEJiEXHo3UiiKgywH/jA3RGu85kOoJvqij2qe/Xn+VEg59Hn5A8jh
  27.630 +5v5mM7sDw7JCoBeeSIwL7snGJJ94kjQv5Phqgrg2UKcIMDEpOQpgmjRF8tbevS7k
  27.631 +cQGBBVbRc4qJ3w5R4Epd3NCHdfZCxRuCGuXS8mNh7QtxbJHRBocQNGTto6Mp36Zg
  27.632 +u6fU40mO+JbOlEDV3Fm6vxJaQ9WT3Tr4Bvx8Y7MHtaOQtYjXOENhTrz9rJGCjW3e
  27.633 +MhJkpV8v/wQAJufrqUiq7VMlIt9nzyNArCrnG3xHSKWJFA6fOFBioi6TEGmahkwZ
  27.634 +Rdw0pkP+4FGhj/+cFuWWEGsw+UFOHlhEKsBY/HukIogwtErSpkudA5gEWl01wgEI
  27.635 +AMmx5C+2/+NjMpxHM+T47F7wKOP75do4SuJrLTgm/f3m66eqV19LwEfEUDTQH0Gw
  27.636 +HBUUnoW1G9HWTC7ZiGpA/dVb8hrKyJDVjBp1YXT7oFg/O0UqwWpnQuiRFsQ4O1Nw
  27.637 +3wtwWHBTWrOHszpMKWpWrE6FTpdpublPLBmlyLpYIblvnskoK+WpJErryIfeHIpO
  27.638 +oBHhlCt+NEeOwKY1CSC3p1zd9cf+pUdnA5aZMRPIAq3JYJMz2FkufBFicNOcNkO6
  27.639 +TxEovNg+i8DDl/Ssjvl0KahMH9BrLlfVXLoWdRQG5CDXBiSmjfa4XVF9Q9/+nFgn
  27.640 +CLpVxwqK95H9qZ2Vyko8Wy0AEQEAAQAH/AgW4uyI/e1cSqja8DlkRHKwViuCrF7a
  27.641 +uCIpo0gnxDMdQmFYoyV2z9DxDjh4CnDjg9TSnWMGdwWs/yQ35FFCpwuaIvUxIecx
  27.642 +MWvUPmLnPrCbZKCrDNPcLWJPg2a+TJ7VnZSDXoCuzyn5LNaPPG//5uxFS3gmLOVC
  27.643 +SCYFMK5Mn5mkzrJ0p1orCa5ECaCNH9PlNm+ALfBuH4oKTFev8sWEn/S+kmQRe+UU
  27.644 ++ZsNmEfO7YG2b/bIEY/ZkmkJy6tR8nmoDU+j1rxbhLjMZOGxAj5zNOQ5oGalKDcE
  27.645 +YYKMFlnIc4OAlrOXxW82UYOxUyI6o/3JqBbgf1/op2YlpHDAAkZizIEEAOBtQq41
  27.646 +l5S2nLnLUWXFbpERQr9+Ghj4kyWTQk5yuIpP/+JSCqfaqrLVDUxnhrusmvP6ugoE
  27.647 +/zD586kt7/xxDdqIJXD4m2qCG2Onprb1uh0GV3EzUOGAk/bim2VsyVLJraPneB99
  27.648 +uW+VGL36J3efJSeOchcFtQx6c3vK857wx6DBBADmEfC1wV3iPLr7AW5vq2ccneaE
  27.649 +wUDaYSmixQEyO+jcih0HLOt4uBUe1sJBWkcXHy8jMB1xbEbWWqnHyDAFEvN1ZJ8j
  27.650 +iIrShQNMfrRU1DQM+uxkLaE0VEzKT4JgKXm6cfvVDHyvVrBCzvY9xbjuCv+mx88D
  27.651 ++0nJgqtIz7dyjf4pbQP+LgAPIjuG29vUQk3YLNiYuoXO76HzmUwmjx+n7yVYGWgg
  27.652 +ecvX0xaicQVBkzdZr61/wL4PNbJVFcXyQneB5d90NBaE8Xc52MaPI8G+m7uNP1QL
  27.653 +MxSPKlCcoC9Hj4eFLFdeQYD9E9yJJGdWWW2GC15zd/RqfLE0IUukXf3iMwI4wro/
  27.654 +LIkBPAQYAQgAJhYhBNRLLWZED38Zcro7RZiEXHo3UiiKBQJaXTXCAhsMBQkB4TOA
  27.655 +AAoJEJiEXHo3UiiKRn0H/3bl8spXmLbKX/KazulNRLrU3HOam5MNbA/pwkzQ33At
  27.656 +tULWkOC/lBlBfjPtkLJrqidLf7ptxPG059sZzKU7TPMuYibPolzcFuBi0Wyx9cOk
  27.657 +ssDxubtqLEo9fAqn/plD0XAHHlM70O1pYr5b+fHJbesz4BXFrKW7mdtOso5XV7oF
  27.658 +GfO2n2zruwyAQP1E6INHISmbUdskKPLiFPIuzYDY2QOUYOj1rH2zeKnlAybKYfmO
  27.659 +/UHitRkOh2NfRRLb3phfDcRvxOCeXf3pHSjUVGpdaMNr2+8fexxdTIT84ZqIqmCW
  27.660 +opI/Tv9HcME+KtY3t6YfuQMoaDwjJIP3mLyHf6hPUxyVA5gEWl02NAEIAMIxf0qz
  27.661 +ipLSYHbIJzAwrMsZLJgRZJQb0deQytqJMKZsvyP8a8JusvHM1SF1jT9lOvkVHytl
  27.662 +fer9wNlXxn8gUQD9ScvWcoACZpOW56mRGhVxVVQnWuZf8a7sbktw7JZ/kLaxZ+E6
  27.663 +W7z9M0BWnYD62Hi5+AAz8FZG+sXAcU2waZNWCoFj4RqOJPB9x5ebKdOcybwYONlV
  27.664 +AyeV9nqk/Xe/DVBpsA7/cbafHtELQJgbAsqVWeu1DoBYEKPZB5hzWM5CHRFx8HYX
  27.665 +c6CsA2+RED/NoH/fl92YiWuzcsL14CiXNmcLzKdD8khyypgv5UA84XNnti4M9uUS
  27.666 +ndXB4lbx2V/n0MMAEQEAAQAH+wU8KiELSo+y7fEua+ca3R960169BK39AADpfDoo
  27.667 +zI1fYOOVp0DzFMksyyo8yPuo8052YH9PVydPUf4p9C0yxixB2P1nQOfx1O5PPhdL
  27.668 +3qvLsiiHV4ijgPYAC5nmWP/z8MwKLKyJunqxDwZLpZ2QUecTRAqu5ZufqbBMg+tF
  27.669 +bbPLVFMdDlbz20e1r+05HGYSuMJLwPqfH+9fjUAlx3yi/xE8l93iZ+r9eFTqeVsz
  27.670 +84i31AWbmHwD+uthz1IrO5L55ifTbPlu/Orc5UqFZId4fSKF9XBxyugvQUYhcs0l
  27.671 +Jla6SExjfIIhWE30j5uNODUVDTtE7ew843LDXfBcnJtyPskEAN4ZurBRPokER4Ps
  27.672 +S4A4CqIreFRz/gIOMI4X0KW3nsML04BZAQtoSFqGkOC2TBa45iCKKe+FXPh6yNgY
  27.673 +JAc2XKJOccJpJTSdsYWZTDRVS6AJuRLs+eyjVxAU1sixWEGrVRc8IBcefO4IBNlz
  27.674 +qTXRYaCHhubzvA1///0wOOJUuoq5BADf1VWYbB9rE3qo7EhMruLzIApqWh93PlS3
  27.675 +Ek+IgUOa55fTm49g+2e+9RCp5/YEOHn3YfHDln3xexaU98+7bfZ4Mu4YpeN3MXwz
  27.676 +HpTCPm+crdtPbhHaIQWkBkcgoZHKi8XrX+y8h0fieMIj5cf22SSkFe3EM9SHGcdY
  27.677 +HQHBDHgJWwP/QN+g7ZXgqPNwa8kkVcat3kACqS+EAs5yEtQ6/4OVF9Prj1RdeICy
  27.678 +mdAHdfbF8D7pjGwg/JoqK26wl816zvGmmsl1m41itAUBv5/xySo2vBK+CKAVcu8f
  27.679 +kCg8Mi6c87s+qbNs7vtw8mutYeHMTTg9VhhAorVESusDSxgQ/2dvLfhEL7QxcEVw
  27.680 +IFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokB
  27.681 +VAQTAQgAPhYhBLwTTmTPjEfBVh6+T/P2h9zIQ4IMBQJaXTY3AhsDBQkB4TOABQsJ
  27.682 +CAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEPP2h9zIQ4IMvF4IALzAjdWaFTXQcHno
  27.683 +kY7o5otLJmOatirnr3P7fPQbhHgeobXwhAQxQeq9OTPzfN6LVL4d9pNjARx324N1
  27.684 +2bks0kV37oSeBeoKSkHhKwQpeQIOUA6wuRdm4Ka6Nq+1wRPhZYlRwCZGqZQL7xMr
  27.685 +wqLML2bI1ZEeAHum2E0T6mRxR3dyr+Xko8E2E+wy46jpbTOUKa2VrxSrjqESpbGM
  27.686 +XVGtgiJ4ig2fL4uG0aSlpl3TkzGmaRYwS53J2MhlKsMTVb4EOg8zxUEiGkCqoUAI
  27.687 +KIGAifDWYpTIuMJduSIIPBf1ITM7gBlI0hv/INIBSejGOEoK5/d4qtYCb+5UZSvH
  27.688 +SLI/jridA5gEWl02NgEIAKsjvnOgFetfKaRo0X6wc+mxTXEnaw+U8+LG2mBz7CTF
  27.689 +DlcyLnjTR/Dky0av3MLQ64CSBe+OLp/0SqXTAMxodNK8Xx/sut+MxrImi5k1hco3
  27.690 +G/Uub8nmCdkSrAwdnkOwiGhGwZJf9hyU6djTOZJ534NxNIq6X44Z/rwGUIiB1hMe
  27.691 +r/uzXVzentw1dld+sYvkjOp6fJu5Xz5wwiFFLHDeRj8cxL8HpWmZGkWgYAo0HKEE
  27.692 +3cRI3knJBZounmX+29kFaks1/9ulORveS/qf3ffnhigeD2b0Yh9Zkojl3DoURbel
  27.693 +704wAfcQl/CfZR5H9h1JqxjQ4YEY26s2OKFbFX0RQb0AEQEAAQAH/A4bQiWRunzO
  27.694 +OUZ+BVamAMfwf2umTiLYqkm1DmcI5xwYyhfR4RbAg5uNoFvRPycnxWGxp5+ZXqp8
  27.695 +nnKQs+4lZgvAzy54eubWWcJxfuxABykl5b4N99TyizlDWr8c6eC2emft/SKtmkG8
  27.696 +3JGsx4AVX6EcAbK1rg6ugdrJwnWeDiFBMcSo6EjImy237emZSfBBcgfE1K7ZmITL
  27.697 +8jzZ1mVY7+IIQo+7Sy14FJ/pWcdEq+tlMSmdCCSeWvGSoxuWeChuIQWTuRUzvp5V
  27.698 +IXvojudwd+tmml/IiN/nsQApaTvVUUHpbV/m/Yc4p2MGYTnMbT8Jszl25k/PKmCn
  27.699 +yHd3O4wwlxkEAMm5iIAEbH478190WuIC5ObXC7JLQyxvP60hX+3PFG5eXD1OqMa5
  27.700 +nLOwjxmXoj3uPhHVU+e20I2dATBJK4vLAzK5Hipvw0Q0gWcqLCkap8qRxlXQHlsk
  27.701 +lg2yzX8Qss3pcnQdeVgOMvuj7ejPTBTRlBsrK9YQOSNHBhySWgoWk48TBADZL48A
  27.702 +hf4ebkG6T1JGUNLN663kZNN92zTrQjzbV2sBWHO6txVHGToAygzuFWFJUoXAVQaC
  27.703 +S8R0lI9+sDpZrfu0B8Yyc4VFRfcDqcekj/A+My2nR0XWDWiVDPP/RVCLpqVALJ7m
  27.704 +p0T8hCaG0hSpr3eonFFdZEsAhvbnfdDZMcl17wQAnBcB+BPOjoaDgLkLZ9t3vpBQ
  27.705 +L2hMZlkvx/Bpn/M3XtkRuE9gmh1xBW19MmxnOS//Oj69zCJDMRt8FZLWHMRGe5R8
  27.706 +YgNC+OVniRhy1RNNKti/n9M3q2pfjXbyuk5x52y43u9m8AsdOfa/fVyRPiKNvbmf
  27.707 +gIhdB5VtgnwuiPAEAyI0KYkBPAQYAQgAJhYhBLwTTmTPjEfBVh6+T/P2h9zIQ4IM
  27.708 +BQJaXTY2AhsMBQkB4TOAAAoJEPP2h9zIQ4IMFdcIALqGBDUmSZzDV69VM9835cyD
  27.709 +0nz9Uu7C68nwkeVpW4koo+BbOiirOek8DH+knV3B8yhFpw1dkWiJWBTYinmJ/sba
  27.710 +3J7q6Nk1s0bmJXjJCtFBaanUncY0ybBfJlu9sOuzWXLxUf2CcK2iGebgzcaeOUnb
  27.711 +UjbrFGhp4oKy/9OsKX0YMd35ahjzvE2Qi+qR9WCIfVk9vvRcD7dhBHCsOaUnwThL
  27.712 +uIZ86wyJkRbtDm3tQyqrwB8oS1aAgBEvtZVRud9xwOAA4DmWLjBliVebNkyl2fLj
  27.713 ++oC13vTPV2D0MfD61w5kSrkOn/hZsnzLfz2J8Bg+GFej3myZ/+f8P80Ro+kidYWV
  27.714 +A5gEWl02YgEIAKzVegNE71UBwexUA0zPnBbvmqh1xu2/IUT8oNozI4SAvD9CcXdk
  27.715 +8nYr8ExNM/XjauIxA2cSUqZP7jPpEhHogVhScy8b8qCcIPDP0Php0aayZ+r+s9P+
  27.716 +fotOMnFZAvDFrq4LQhO5TCKpGEyrVNyYdgq6chaIpnCdz2apvP7QPk9rqbztVSDN
  27.717 +fQkszawNvGnhhpBIfYroCCECMxMKiNF/HUVFXOpf1dWeiwdqE99fc31fWbBGR+ga
  27.718 +jdMIIuWy4gF1RPi2X2id7OZJ0aIDsVznXoBFsmWyJvsBpxuI3+6OZ+se06rXp8uj
  27.719 +SKsJjg3ce5EpqnnChydAOXEwYzf2V+MM6jsAEQEAAQAH/03McHZdRvB4cI8NiEjA
  27.720 +oW4PoAoZrhih8vtnTo65+1BvVI2TPpk0dxHrmGj4TZ3vJ1M3JeV1MYAMtdhnH0ux
  27.721 +YdvcjV3U0kQq04civNm9ZHKJl06IJXGVeugBJKKyIyk3ivhsN+vB+rwVastESlhc
  27.722 +RrJwl9991pIV72CyolD/czTzL2qn1E99nJbJpmPHW4VKJOaKdKu3mgqhulwZARM8
  27.723 +MFf1NdI3cmYjnx/tq7W2pVyLSZu3vjqvCVnG0R6+0uDBfTK4Dry9yrLtGPlz9Odr
  27.724 +X3XnT2euI7U2WnW0tLGOGR/ZozIysyqRGSHab5QJbeiktC35X8NXr8ruMWLpK14R
  27.725 +/IkEAMRAzTAOnZb8kga9qwPRqUsLSiJ+Ba7OZqYYBnyv9dP54b25PjDaXXAk2Vx8
  27.726 +WcYopEOU2/uijzyX00PLOyB+fzu3+pAbydPyubAXx3Jp3eLMhNxKzek6R5vAFUGG
  27.727 +ObKFgsGZpOgRVEWt6WCwky+X0AFOnZQ65JOLFBcegVUOGmVJBADhc3i9xZfPe8LT
  27.728 ++GFdX0HMUx1eTHW42bXSqAApnbw6kAe9GcS2cvyBK4e5lVMMQGxlApbayt4vk3Mn
  27.729 +MZ7mhZMCde5HxHBgd7/pdYoR3542oO/51gdB12SF4PwGuuKBxeRh55Aefdf40riP
  27.730 +b9/HgIy34nMkhzSXo+Plue98xTzHYwQAv1l55mHHbA9L+o5KszxJShxNocH0pF1r
  27.731 +lZqV68z7CoYfb3f+AW/87dxfrT0AEkvqkJFnEb5JOo5UrZh6ztTFRInCo22xQHjK
  27.732 +E7tOtXSgmDAaxfX2RG2q49Wx+3jRMbgTxiShV72rfT+CRzQuay9KzIPLNlz6VZk1
  27.733 +fmulPpajS+lMR7QxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBr
  27.734 +Z3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBJ5hMe0jF8K3mSp4ImK9mmZxxvLEBQJa
  27.735 +XTZkAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEGK9mmZxxvLE
  27.736 +Z5IH/0apXr6CH5nC4T9Id0vm/PJNbMweoq0RfK7pcGuOvQff3QE8Rhlicjgaw81s
  27.737 +Jm7iqiMQLhiGAGCGFd+4C7o6tO/JRDG50n2xYzUyfgcrHR6IdMKPPKh3SxYidqpr
  27.738 +a7YNW6zyJwZPBqaUyciSOEoy36KBVDEciup39ky6DcSG9Hn+fhIx91BPPZzGIUXj
  27.739 +3JPUH+M/bq1diQ3+nc874jMmvfwhYTZok6rzJakXRNYUjskqanU2oAWJxWWBDo3D
  27.740 +sRVtfy7Sy2GD6iWbfU/+SwDDAdmh+dCLBzZZuQFlqQC3MA4gS3qihLXk1YgzwJq7
  27.741 +LP5afYl3uslJuNvhMztF9iBKLDadA5gEWl02ZAEIAMg3k3sXxi+cc0/ncgsh/2N+
  27.742 +JjAuhn7FGmmRRABZkQh6nbN3qmqfJd/IJmlpTxOGfMnz9/dLjEjRc296HoITtPqa
  27.743 +/m/l7EtmQDueQyl0u7ikXzkhSjxyHHC5lKMok7H35EEluJz+tYz+gvfiRMOK8BDd
  27.744 +R3BS6PvQozFnXmxwqbI0u0i933XnLobeWKeYSnQ+JhsIqJBR8Ri0py9rti/ZsXxJ
  27.745 ++JqXiqDHK+dGgzlwBtE6UBhIM4FyOWM7u54GHCEEPX0W144A6cvrC1xwDrIkdnzZ
  27.746 +uh+RKMugmMjtmt/zMocQbCNa0McCxcEQqdDZVejk71NiGSpdVkv4gHOhae2bojcA
  27.747 +EQEAAQAH/0Ti3kLBRMZ30TLiQlozOc/tBM2aDFtMjJBa0yc9qcldiqnHV+J0XE8Y
  27.748 +6aJmAbeJk6DWaG/01dDuA4YM4bdGeYOp1TYBySGODjaU9q2qRLY8E6kv239dkYx1
  27.749 +RX83hE18qVOC23hkqGlY3g3Uk20l/gAHaj9qv094ktV6J8IupywxHTn2+5eDuNdy
  27.750 +Ur0tJunfcZAGEJ4TPz5R/fHBuQi/JnAQNMG/X+CymjwuoR1AU8MW3VrWsX7uEtnJ
  27.751 +PaDdCli7/oxX2lqrTKs7l1mAbKuXPkpdMbpjsumvp68UfEHFaQyvi5uXhYIUP+x4
  27.752 +ZLCd+ne3hiIyGESZhA1Keb5SE/eHTFkEANLcy30b8K7I2qeSKM2Swo+GKG5dWfVo
  27.753 +T/5UtWZf93ejH8GkIO4AG8LML88nCWs01ZykFQo1MOOgibRn7L7KqpuTQEpAwWPF
  27.754 +6xmIIkr2KTbJt/xEoGY+pE7+NX3m5pnQKvrLCj0lkjFfPSgoq7n+3lmZ1qaxv5CJ
  27.755 +tbxv+zRT0pMfBADzE2rDPCDmSIurDKkfMWrWTtpZs/MO0Y8oXb0e1ZBd1fqJ3Xew
  27.756 +YDkG21R+/xy538SjFfeEw64KKogeUGoEHrKyKW9MDdaTTnKsrlLn2suYPL1dso1K
  27.757 +TD4VBlPqm08JwhnUSZf+VtWSqlA+UJATRmEYWQWhv/ImBpQ5qkoXUIfl6QQAmmfw
  27.758 +/e5DK5aNMrq4wp7PtVnT1qos1jEbsGRaoxpqAGwl1jiT/RI9bfoEln6sFumc6s99
  27.759 +4fqgCwp8mM1yIUhxXp0eqfuD7iKDbo1fIILIIhtqTXm0telOFSsedcZvfxsgwddW
  27.760 +AA2dMS9yzqwN8JLL5CjIgEbzcaHoucGO6Bm1CwM+xIkBPAQYAQgAJhYhBJ5hMe0j
  27.761 +F8K3mSp4ImK9mmZxxvLEBQJaXTZkAhsMBQkB4TOAAAoJEGK9mmZxxvLEdIMH/jlM
  27.762 +Ba0+FoDxCGToSV0iTQL/5rOTSi0gsGWwqGkab44uqPGXx+wlwq61G4W6hT3xwsfj
  27.763 ++HBtCdGQG82l1yBf16OevtQe1QqPczZ7zBcidgNcXq9Czsavwrsc/vHV7g7AC/VH
  27.764 +M2cUXcud6yTCQHXGrzWrMm+lfmhPIfU5ZmrTzRkNO2yCgfDf5szX1jx1r1QciBiz
  27.765 +sjHoZ98LArdsZxXKYQOqHhE+JZ+/RBCIyCK++iypFUddPy9/dOAmnOmCx8OXViBc
  27.766 +chnqUn5XOLzWsVHVa9XIeHSemStz/+T7HeOsMKtA07oUXt0mCmVnlzQnArRKY/7C
  27.767 +e6WXnY168d38yEcuVFKVA5gEWl02cwEIALasLtLlRCbPDtki7xWxh23u2lzd7Py/
  27.768 +Rn3KhT6daFKEcUSmeT4pcAenf5cBCRiJ5RdnzTuJybg/KI9/9WOk9uKkmJEllCB4
  27.769 +rJaoFn9eOSxd5lYmeS4x8Fdk0h55j3FG8tWabd12fUfcsyxHZQdrYR+NpzkRWH7x
  27.770 +y7xAaOMj2FCau+leB/mud5A5aLQdslPT/3mkTNBm6mEV6BPIbH50+nmuwvV/jhfz
  27.771 +co/+d2dnCrFQlaS4G5UOBhEYYSqVHxvqjacyhSbJy4uV2aVCZchJqjuICDbNwjbk
  27.772 +NvtQiKkNPR/E0Kvve6OGuDgKueL4jxjHzkxMAYYZzmLe52yCADZqso0AEQEAAQAH
  27.773 +/RvbI47JzbvkolKEAb/QoSLR+XQ6QWaEx+aXHfzfkGYuR9QyAKt1MojFnEQg28wP
  27.774 +/HfhE9+1kiW/DTEzeu5K3H0mSr+uN9RAeAJyDRriJEd65YzonrJn2iCG7DB1KrsZ
  27.775 +mHPwnJADfspDwleJEZkb4Pp9+uyjE61+s39NtnuWCT631Tt0vpiujoWn84xyA5Fd
  27.776 +iTd0Tfs5rMG1z8Nk3ZFrIuU9H8amdXGAJkm1XjdHdEeFeGvCk52ioIJb23PebQo0
  27.777 +m4fvp4k1/dBlwVD9JtMaJhzbw1mYwIzAA4rsGYwBaVb+KA1YT8lf3ZuABW31QXZZ
  27.778 +doWNk3Ylt9nZsHLGqBOd/p8EANf7YiXXIMvcyRF28VW73jTiytptSUMfOBP1OF0f
  27.779 +C2JhrAor8fvxHLAVf4bHMmpr31gbj6oxop0mw+IvJxzHvExhXQY/Z3P1JwmRaRbr
  27.780 +Yg4LZZJmwbe8zaMmu2xx4ba4zM4trHiMjyIlfRfNPK2pGREBrJ9BC58HYTQ6VY2M
  27.781 +XTXPBADYhNgvttxU40gB+rub8c4L3fmy4flcSX1ffEMTt0GxmPbdmC5b3l17m4Tn
  27.782 +9an/AwxgGS/nkefxC+24w/3g12KiGojEwd5+I1J+Svh5dbHxm6Sc7WVWjkatKoLi
  27.783 +p3QjDt4ca65VqWeLd3noEVpm2EuN2KsQdcFGCu2la3tlMjdE4wP/QwFHkC2LaCDZ
  27.784 +4PsbIYKCiLJzjkMNb01zJq12DNhcfYA05X6qFsuEO4wqv614X83CIiLWmMX95Ti2
  27.785 +aL1+RMisRFBqzmKEXvtR5cqt8OOfyiEYVMko5+YOgv55+GksniksaYQ3mZxFr0Ij
  27.786 +zu5P4nejw4BHCFIggqMhfshmXXXRTHxFZrQxcEVwIFRlc3QgUmVjaXBpZW50IDxw
  27.787 +ZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBIuLowA72bEA
  27.788 +wwwcHVJbUFKMMI7wBQJaXTZ2AhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4B
  27.789 +AheAAAoJEFJbUFKMMI7wX74H/A2cZtaBm4GbRut3V7R8nR4SHL+c6rdU4dFnwZw5
  27.790 +KxArVdHxpnaXlqyzzRcbK5vE3+ZDwMDe4m749RVVbW+ii/lMDrVxi/ApogszwXAL
  27.791 +bI/qI7un5KWCzP/wQtym3HBDKcSfwdmkfM2c8D9dFk3/MHXjl8jCOkScRGcwmyah
  27.792 +OKIClojgdYdgeztWi32d4+HLJcHUOpUEVlybblzFQAv92dmvLqUwfgm4EiUB3DQa
  27.793 +d3uULn7F5oT69Sl75EBDTFckJik2W76fq3xzxpXjYurqfgJlDEhWc+drspf+ta2C
  27.794 +krWnEz16MJH9fJRHqCf9LEgA8u62evv8xTgOnMXvAw56HpidA5gEWl02dQEIAL4r
  27.795 +IAxvAy7EbZakUIbvI/7Ghnek3Cna9Byl64wo1ZQ2rYC9oJsqLcySOhzTtMSaTy1U
  27.796 +8+nZZhzmyh9+f9zk4htx8QPHaCwzGmy+tzJRAonH4WQHCXSMczbqbznxGHZ3LBu9
  27.797 +YEQcs97zpiqFu+F5oz+or1wjIXOSVNTtaWzmLDnLMwf6fzM+uaaYIqeLbInbHU4E
  27.798 ++D8YWIuqo+VL6NsWULPTCOovNIIetgtHESZHUwfjqTPoyan/+aJPsztmCrDW24UO
  27.799 ++/KDHuLnMArkCMQg1DPqapmXGT+NEs3LrHtwzQGtqG5dLl5/Z2TBrOUc3L/sKi+F
  27.800 +JIANjkZtYTnUpCV7wIsAEQEAAQAH/j7t2Gok5kG4oKcj8r3kLt4lZeP7uxtiqDs+
  27.801 +sKat8JdeTKX4mkgeeg9jKDXX3M7eXWsb3Kc62K6htKsdWkSHvUbluqLMfu15b7oi
  27.802 +lk7hPdzINw65wWg+/fVjOLFM1hKFtyPq1AtWEDOsHwWdQaIIdXwgXv83ZN9wwf/A
  27.803 +HI370RDCWcKDNwMHOKDn9+3OKV5o1xR3l1GFFB5ukrKd9BQ3UcyaoYIrGiD80Faj
  27.804 +olAiQQ6CbYjR2G+allE9Jw0m5RhhBDN8bxdvHXaAKvpmkagmrhRXxpOq9wT/bFhz
  27.805 +u+2O1/onAE0CIOC0uN7l9jsIHMBl+o35pQu2WaHJQmoO5sHyuTkEAMvxa2nY28dW
  27.806 +wXfbqPtpe0KE6wfkyo2NAW8TmrZlFV5bYtDsRbQ6u2Bj2WFqG2sRjfmyYuVGxd6s
  27.807 +iQ6w3mdCPxJmy9gNIaLQMrKV/p3EjGA8rJJxePaCsZy3hdWBWKn8kl681LMUJVoc
  27.808 +uau/clr1zTPj4lMJs/P5FUim0f/NaLKNBADutZxGQWTf61RijoZRrEzbELLFkpgL
  27.809 +2nj79J0J+F2iRxrEGXrSBcrLpP9B+zkyDIJgS88Wbrxj77P3A6SFR9OFNsKw1EYf
  27.810 +nU3Daf6MdH9hLE274VImL12Zhmamt6yU2VMd7Eo3GVJHIIAotBS5hgBgsC7IGOcG
  27.811 +rQTxr+dOLKQFdwQA4Ge6Bq4ih0Dm2JbkViDeY5ILMlFsZUubep7kgLM7ubvbdG9T
  27.812 +WtwOIH5Caswu2lwbFxxhvWfYRelU6L2VGtvf90Zuv3AWm1v8cTfllrk1eH8ONfhK
  27.813 +owbW4Xce1DU+eN/HjbLJbfGqNLNoSqaeBXn/4BAgyMAq0bFozZXT3KUL+S1JPIkB
  27.814 +PAQYAQgAJhYhBIuLowA72bEAwwwcHVJbUFKMMI7wBQJaXTZ1AhsMBQkB4TOAAAoJ
  27.815 +EFJbUFKMMI7w05QH/joFvdYvykTSVb9P3hvSSly673Jqt/3GzNCYbKGniUgeGRPV
  27.816 +S4iSMm0xFrA7ScKXdMsRfpk+6ZpZzEzvdoSf46cYDE0dwp2KbS/GzP982jNCIN1v
  27.817 +ytYatBUe2oN4dmmXBdHvlHUVeX1xvdwQqnN/yO8oqBbT2IzJ4Zpd0bdGTiKYUU3F
  27.818 +YUVGPiANdThIwOn2m5dRsyNj0n/WgjHeOLWOft75DjAmFOv0SiQ8XVk3AwRSrCeY
  27.819 +lXofpZjwYc+ty9NMLzkMEQCK+3i5aQ9+1is5w4d/88gM7bd34Ji+NEi3GXM1fVra
  27.820 +RsolCVC4WSUXl3nmlLMV+ZHQwxE/lHdzqJ3ADxmVA5gEWl032AEIALnpeEqmfZZ/
  27.821 +tSYbdNNItDnlzvDiPa7Utu/8/gB0odbncKnBlPOK/eqtEEw4jwjE3PlA3kiZJ4zU
  27.822 +jWxTzvVsGq5/U9qjZoB2e+Zzyv38XDffHIaM+xtj4LvTZgSNqwQl2j4ExbxkVnbu
  27.823 +XbqiHt8alnv6tJ7BZLKxTlud77IVfcm/gCmEaWCXMM7M4NBnFtqTD18gQqKSA+ID
  27.824 +yRz0K0DFe9O771gk61u/NgoD5kfDdVSMDFq7oIauWilf2Ava4VBSs3fJh7ii/R5y
  27.825 +t2zz0GL8CPB9vIFNdDkHHc6cI837Y4ZnJez2vHlddQnNgjP6sqindVf+vH2svviV
  27.826 +1LtYrfDm3zkAEQEAAQAH/0Z8FMZArxazHmvvNvCv/NyCm13KeNZjAWSlh2uGzKEc
  27.827 +qCNEKIPZa4Fg0fAD9X6+nITHqj7eChejsmais7FqpgcIcTNQhhkoUrtBpXF8Dz6D
  27.828 +kV4V71IoINk1QdVyHKd67m5bAtj1Na7rmo+azZeKjgk9OOODsPjqrimgDHN5IHKv
  27.829 +Sar/PPzdfKJ9LguyZrBigXUwaHLXputfMClt4aYrlKEpcgEnLG22GjTuVzPJkmUp
  27.830 +iPKw1DbRqYU4XPRY29kBN0wSTdFZAT8bUJG0pwyY+6Gr/qhkBKJIRSBMgoamj9dK
  27.831 +bg9d3GumdpM0kYu2fXwvGl2v7ggI+ni4Z79C3zFg0h0EANhWIszCoDcddoaRb/HC
  27.832 +uUfYJKX6tSjSpkO7MwOALGUdV2lvVFTTaOyvGlZnbgGnKZZTCsbOxlpYt2Tx/xhW
  27.833 +YWrzcmrFSPA3bwdwdB5VOFvU+ln54NelifzVLK0A8is8V0BQJdeETudJFb7Y0VS0
  27.834 +ijKALrfR8oIDN23dTTPY0QojBADb/1hr7x30/AasagHIspR47ay+68zOVeN8c/rs
  27.835 +d9CaiEvIotrvxL0HifNRUJkkHApGrMTHDYlE/bGgudYDaqrmZeN5BbQNQGXeXDOc
  27.836 +KD4tWmgrzjWnphja8u145Aq1cSjOXFR6FBH7eTPtg2eq48xq7I9UCR1BbDyCoJIH
  27.837 +t6DA8wP/XErIKjgltpGxdqXGOHMUqoGtjXsuuMmrisyNnau22rhy9njYjNrYjqgb
  27.838 +dGERMmirQ8bVrUpqmHBIbuWHD4fLk1paBCVmwROSAFr7v1PziXbcQjq84a3vnX7+
  27.839 +tha0E3cmesjKnGPqFnEDCNOlMU2wXZIhDVCLKCgvwftYNPNqyCpAlrQxcEVwIFRl
  27.840 +c3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQT
  27.841 +AQgAPhYhBJvDAMMpGZEcItz82Gcj6LnSLrdoBQJaXTfaAhsDBQkB4TOABQsJCAcC
  27.842 +BhUICQoLAgQWAgMBAh4BAheAAAoJEGcj6LnSLrdo0IYH/3KLv37+7CqZZl4z65OH
  27.843 +6Umc4qAbBJmvfegY8KezjSH5UsLHskAskVNx9QHp0X3KyyLezIJfMhTFvCYxhIa6
  27.844 +sABO2sXfRSBAhVbydIF+AENxyN6nW4llOx/IuX9OvB05kvhQ43Ngj36HAhnMnpLg
  27.845 +6c4eo9bQhhvoKJZXuivR0wWUQIZzAbZNaEp8+B4GYVEclojvTc07bJwsaIloQh1M
  27.846 +tWRbT+OZkeJOxB+15Sluq/AZA9y5FEZ17Tpz/ls/5o9W4HCUbHoK5/IY+5qMw8O5
  27.847 +ziQR9NKhE4kv58+n35MtGPUf80TodbfsOC6OVHKbeuVoDGBNRedPjQqukt/qevVt
  27.848 +rdSdA5gEWl032gEIAMxAcyz2VwB5IHQ5FrtnN7vTS0iD89LbuZrIcd9Ch6RrbrCs
  27.849 +HgGv9581DmPsNsa7yRkzotXi0S1/dWbk8JdUpMYxeDl+fNQfydnm1qO3O4kdeaCp
  27.850 +qeocacjwNiOYi7vyxLK1Gh9ddOQeJQS6FL/w+wxUkm+uHp9+yVEz1m218sWIlANe
  27.851 +C04nLiN6JQkXOkd4wMhAuAKnSbw/uAqBWNEjEXsGqemyxgHdEuEa+utJ2X3HRwd0
  27.852 +cKo3m2LVtghEmpIji1QRCtBMuP2f7ItY5FMiTkDlURoUJ21GdBI/im3aHoDi+6BV
  27.853 +8IF/l30tu4VmmB5LjqwS2kxS5tUA8DJsjHJ7UZMAEQEAAQAH/2NkHWfMu8t0JdHI
  27.854 +kgJBmQJiMGkqJLT/zRK/5YGh60WcLbH1H2jsyw+DDuya3pDYgmQsF1oDVIzSUDvw
  27.855 +vg611rTHD9zSa0YB7gSF6v6hxGvVlwESbqeIigWItp+dtKmR2huoOvz2SlJTROpG
  27.856 +7p/0UQXQBa4oyagNV0OXeQnMF0X9cAVqogQzwIBO4t7iRc8Q1v+bLvGf8TCG3m9g
  27.857 +Kegi0l/xqtsU6Sa8muiraJsNAtgPdLeGJFRUT2UFMTcYU0XRBW+M9MOusjtxwMb0
  27.858 +n1AbfZ+BFmlsHI7rHs3lAl+t1pNTXcUUX800ZPzFUtE7qvQGxlzoghRkhx+R635Q
  27.859 +o3M2UhkEANT8UUXkqJxoMrX9Yre44dQCc/MbCBsZHGQfmi7sO/8VJRrAtUY7D9zq
  27.860 +04eqI9P/COoB/1AmLvAITeZP0nYXzcl/ajVFYVcRNK9L5H17IPMfeuJUOBYiYyhM
  27.861 +VbxRmhP9lVLvLNTCX1bZ/EAC/pNoLjswxnVIdEH0ZJWljHOEQHddBAD1gJQf7gL7
  27.862 +kEYA42or1bsOMecUEF6YfXUJ1tynUajEfpbDFT6t5YAH3efRecrjTEwgxrmX6SIT
  27.863 +/tRXmuSTzMgOdIFLt1Cj3fQo7Ms/Vdn99xkRd4x39Dgfhrk6wUIurL2wEtga/MQx
  27.864 +gS3PKniNoNH4Zd3PXLYiSawaVGTY8iINrwQAzwMWofBsJnM0WmN5SNusLjIlhni8
  27.865 +JqqdOaDGns6ffw0bSDKybgMEnPZLAHVwkdDrnMwM2eq90c1OtbqwqbrFBXjTVEz7
  27.866 +kTdGNztRsjCRWfG7t/Vzb/0wLyPVNkSb3A0LMo4x3j8HmTNhlbZm4iyOVFapwrCD
  27.867 +5/t31BAkXzWfiI8+kIkBPAQYAQgAJhYhBJvDAMMpGZEcItz82Gcj6LnSLrdoBQJa
  27.868 +XTfaAhsMBQkB4TOAAAoJEGcj6LnSLrdooO0IAJx6L50lzIq1pXcrX3gOX3m3f3xf
  27.869 +yn1Qc/kPf4e/m5ZvOu9PkqKeSOl8WIpAAC/ODmO06twndUp0UXL9Gq7NwXTt2lSc
  27.870 +vwI+ldCmGZKvBAmap+5AIAZBrpfIFnZUohKegVQ1ULwGrNXNje4towjz1LRlYsVo
  27.871 +py1cx+YcRuK2rAQFz7H75RlKkCGY2dFvgqZfTD8pG1DVy7H6SYavUHE0iq6AAB/A
  27.872 +2TWqI8jtYH1iIZ+BFkYRX7NlDZG7aXqRCtPQ84SI9ngL3r5U1CTjTpttouRM1fqd
  27.873 +Ek6t+vg9sMLxV8l3XIZBJv/91z0ZfHfnwRXK7yF9pAnwM6rq4DiBituvJeOVA5gE
  27.874 +Wl08FgEIAJkkTpiMg7snOkmWNyxSYjrgQfGz6fAK5JC8/CAvTUeYZAd53ggiFV9c
  27.875 +Bvkm9YvDRCm1o+Y488GRXEl06qIsSoWavhpDSBhQAe8ZTmEuYubPZxgLQ+wP2AP/
  27.876 +ZLbKb52R/oQ14XctZwn4fSp7p25ZwKNiMbMuILn1tMiBbw7ZtmoxiyUjgYNgBAA/
  27.877 +YN4eMjyBJBj9I+QA9seFHLfBwOIJSCLeGPMr/cUIcZMycUl9yTiXqsb+t4mjll4g
  27.878 +eZo3qBhUf0YMV3qOfQK0oW2twyt5oTEr7iOZT/ygijkWKf+wpmIlBjvaIVnFsXoJ
  27.879 +zsh8cISPigEtPxPi5fMA3Ba0M21zyzsAEQEAAQAH+wREULRLZfg29ZbLSqo/eWEu
  27.880 +kmfLnX8Erq2htlynNL4D7vWOXbNYT8QiakdS4JCOVj3bQ7/MYm5IQIwDZ+4w0bq7
  27.881 +PwS4Ty/uOr+QsvBePH811CeFWNUg8+HYodO9/DIluTOx1KBfcXmDpOkkHNwkQAvN
  27.882 +Vpkpddv4jprvkEqXok9/GtpGyocV6mj+IshGKtxBdv5VxLEas9KW3fLuh3GC4SbA
  27.883 +MQifjGWPAkINV3R0HOux/B36Qv5B871l8SHFa3Cmga5j0EPONa7MgBrGzT3kHMOz
  27.884 +EWqZaU98tVegW2ZfMXkV26iUKAB10xI3Yv0rKGAnGSl+7RW2tNdR3FuXWIcKMJEE
  27.885 +AMJGju9vjrMq2H7o0HFfrXnschQkBl2cCTL2OIPk/275OHFSgGn6DgMXljPMZeQ+
  27.886 +s1IcC/K/uQCJHmnhsoBaoUyV68sFFuJOfRBv0CNatDwKPAXLV5XJFcddBPC5Wyjm
  27.887 +QQD6wBk0rFHE45g/36/rM++wSgT0Fi93VU1WFBo27QHnBADJzB/QV5xkVXctU6nY
  27.888 +E3VG8UXwyMGMXvrbNCZ8od1z/f9pRA75a7o/OlWmYoQ24M9X1PRQoffDoJ5ydbV+
  27.889 +X363v+ZqTd11jO+opWoZaNXYs3Ar92eX3gTllOOn7aVsnwil2+fChUx4qC/bm6iX
  27.890 +wha4y7AdJ2ZKhxFizq/Ir45pjQQAtVTWg+W/QJS9aElls9a6OIXxjPTZwCYLC4E7
  27.891 +TqnEfkcWcAqMHXB0ZZxRhwpzuux/OkPeggiOa5geJuVXhAoQiFn4/BkXSWqcTeAa
  27.892 +tWsPXZzhOBkfoS0pX0gubmr9tgW/k5/ZkzU9dUsOhi0uWh1yoGEjqRbtD7ExIwJt
  27.893 +/PPBtv4/jLQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3Jv
  27.894 +dGhvZmYub3JnPokBVAQTAQgAPhYhBFWeMm2YX2cVy918pjHwlFqWXQ80BQJaXTwY
  27.895 +AhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEDHwlFqWXQ80ENcH
  27.896 +/1I9j73A38P6VyRX5K6J/RImAJQ15CInoF3wwskO1b5Z2aOB9QP0lZFGK8d3KS2I
  27.897 +x5ZHSgC0SfjaaFLOdWSd+cEXF8wyNWkLsUFdMXgnBwpLWiTI0JA3+21cvq/zX80c
  27.898 +vtGdnch6p4DdzZMJzIK4uv3LUk+JFj2V+iwyHcLo//q591VlQMh4hj/2vvXIusLD
  27.899 +AlPKiV5ub84Mw2dg0m4JXIWSovrh3VmShvB5ETgsWVB3fjugFtyKgGZx8UHQY8m8
  27.900 +GTFP51zYF/W23QkPWgnlPYdXoF/cEGkUoOQ0aEf2k2nNGAZmG2lIIfhhLRgSCrHF
  27.901 +oRLNsKelamyU5ep+8qqz6jWdA5gEWl08GAEIAM+hfs/2b3GzJCj3DFOLhGzapO1c
  27.902 +Tf7frjVmaMja553uin+lHnM3eQJTq9w5zKJnplLRYf7Lw9YvdsfVLoIvD/wuXnfh
  27.903 +erCWk7dqdaSqSCD6Fx8hzM611lb0u7O4OH98YmyYAOl3wMfTZ4XSQWd1+169tzS9
  27.904 +5IG1hiPCjKhP7LsRHgYvg9rXajaT+lFfhJcppazkWpDEP6ubF2rsJH+1hRk6A7in
  27.905 +67gbYyZ/9cBB54u2aCXqnktTouikYb54oea57dGg5BXWmo2FEJgjRUZqLx6cogvI
  27.906 +KOOpcVHM0A/Mgdsll5Acbnn09Nbla7rsqEmrV76M7DIEiP8BtAJSCyyav5UAEQEA
  27.907 +AQAH/1bz9R22wNlHAp+9RoY+aYkE0AkvnOJeXqCycLOdKV60pX/rcKMj2iOlUtX5
  27.908 +xr9E1Rzd30JLp4otensZxk5y0yjzalCeNzl49gfcJ8R8I5Tb5478Ir9223qzJ2CO
  27.909 +h+qr9rQvvEIKCswktrgOY6GmgU0d+nm2BNplYPXc5fce8a8tK/X4ej03Jynzp5mx
  27.910 +Cn8UO5wlYFgkohopJ+xHxSSl39GbM2rr5ZSabAofeir50KoflySORQfqogRVznd9
  27.911 +TgGPvLD5TORxZsTWaXKom9gr1tMVLj8OanWks/tk9mEGJIQnnWFux78UYrP7mB27
  27.912 +0SnD7QW676cbKKGTaDcO92ilHskEANEm0TM3xE7+Y4dUagdCeNhhDaR86BJSi9ID
  27.913 +gL4SS2wj8Iyg7qkerFDAlaCMyT6ADfS64hSUz7r1Ch2M3ALHpnuhb41o5ows6T6a
  27.914 +uVBWCLwGGANTUB1qdI3EmlCTr5dGqTGLk3FnbW7owQr6UAZaeY0CbJZM/BIjJgJQ
  27.915 +OLLjvo3bBAD+I3kZ8aeFPj6TNglke0MRYf3Oob1NF0op3+63eom2ikrHt7a36jDH
  27.916 +Bw9lsAxfXA7REFuX0HLWaDJjjyFpRoiFc7klmNzGQXGx7lJVyZmqeSsoZBGA+sWn
  27.917 +Wf/ogvRT5v606vU2eXvsAYWMyLVqm6qvudUIJBjwXpJ1EC7P6+q7TwP+KkFQa5ee
  27.918 +e+zkwofXobtY6l7fRt55TKp7LOWR7BZsV62feh08nsaXKpmrAqrdJ1aBOAptQaHY
  27.919 +w33RnEEG41tCuU8U+rY/LPJaVeXB2IYg6XKalPURzD2xInhqSUkSsXdRjvkhcyQE
  27.920 +flNZ5ctVDPy5Ubnj3Z09pSXiKpl9Fg2oPrJB3YkBPAQYAQgAJhYhBFWeMm2YX2cV
  27.921 +y918pjHwlFqWXQ80BQJaXTwYAhsMBQkB4TOAAAoJEDHwlFqWXQ80CWkH+gMm2ote
  27.922 +VBAHWBeR6jdr3vH3afvpEc9EKxyHm6cB8qh6a7FrhXxPWsekaNNsN5iysO+wPNms
  27.923 +UkTh912RAePDtciUOquY73A7VJRxjoWKTGMF0lA3MUbB1r7RB+By0HOHe51WP9Fr
  27.924 +qZVoWqdAH3senp6N1Ti/yNmq9yxa98LnHPX7Dt6894aab7CtoOB2gZlu3YT3RMLB
  27.925 +0tHBF/ZdfwGXXDX+w+c6prHQTaQ5s6DEdvGxYAKKUMmxFshokwqNa7NDZx9h0IRl
  27.926 +ityqBOPGYFp2u0ko82nccD2R6Mk4iaXqveuoBphNldV32Vira2qJ3/TQXHEBW+gd
  27.927 +R9X28AuHZWwfHIKVA5gEWl09LAEIAOM9HMjcX8JqXEz8exPZqAb3xmlRd2J+RbsA
  27.928 +8yrtgP7yK9zhvE/fjrFAOOvjTyO5C7VlWpmMNFF+z+T3hzx0phBKFuVEbP3e4WGd
  27.929 +nVxfYtMLgGu20tUBg1yrvpAM1Lkt+Zj05XSjq6aSqv3LCya0w0mYSWsBvlnHkReQ
  27.930 +BPiy+lg8rTmgCJmFHb/ioxnUOJcLCygP+zYluCTK+v+OY7mMSRmtUXNXDQr5bMkK
  27.931 +kPsv0NMv1jBrbsmBBoai/ZX6A07Nu5JaO9c8mPA+RQbePTlamh7+05PBEAJi6zTl
  27.932 +7tA4bT1C6RAMdkocwI3tIg7BRXQMHNwkgsGeo9oRb3Ycm52kjycAEQEAAQAH/jV3
  27.933 +0TiP5fZMaXhx5hHXInq1PVnVoeYqeQTV5eGhbbtPRzPbZ6BRpXUee+ZBH4NzzIX7
  27.934 +mbRMcZkFYixpc8gtWE+35yg+D/kyQszhtb+g8BNhfu+ZXoVhLEQXYyjo4/rIjxTG
  27.935 +9uCZjE+O7i32YyLR4KuF6iyEBgKA+ypUqF7OWip9duJR0RyY50rCIMQZHRTkfXMh
  27.936 +vZbQU7Mgoq7aSJHmA/qziPf57xWzl8WbrCLOfp4r4Pa8tVi27pVMDCTAE2QgKiNk
  27.937 +eFLI/39dasOr6CsQ9mZ2c/otyR3bj11QJlN1a4ar5dL3JNqyca14bcI7oy5yFg1l
  27.938 +YFBIgGq1ZmaEu5LP/NEEAOliAEZ8SR2RwflhS0dLfM40C0CT7iHZMYjOMwFP8/ck
  27.939 +9pvuCFTLM3li39sIRYij5E3edyVVkn/htFx8wfhtcgBGF8XU6C3coell1PHxBY+l
  27.940 +kY2wjXCo7oqXkBJ+cVbtuE9urCFbCnRyzI8Jxy3ET6oKKGsE+jcYkSXiPJAeGFvx
  27.941 +BAD5Qq6vFy7WdV+Ql085qPYl6roWBdWhix5eCf7zJc+BO5WWMaWgW41y4qCmhLJ2
  27.942 +IEM86CsFG087VCot1tXG9g0HZa7Dnad+opt3tWlaCqGhp7SRdE8eGQno42aeB5c+
  27.943 +FfpNSIsbox+89F6q5c9LvQeAv7/Z/FxuGNoOmDsVtQ+UlwQAuflDbYaHdjmC3dvC
  27.944 +NhEwiSW3l88Uf6F9Ciqxu0YGM1LaMqXRRVM7yOSSgIiVpioPtpJWCf/a4ITzmUjv
  27.945 +Bx6Nm6Qy+qtOzUqJUdfK6PRA8Klf2W/6EYn8gBA2T2eHhJ+53YnGgvqtNM8sAFJU
  27.946 +URaXGlaY7WHEjpwQzgIbGKce7fpC7LQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAu
  27.947 +dGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBKvftzRxY/2lvaRA
  27.948 ++aKXVQGGzRfMBQJaXT0uAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheA
  27.949 +AAoJEKKXVQGGzRfMrecH/ixP6JLlErczQ1GlbUIwZ+SyH3+Z4pCtj2FiY7iqiKxP
  27.950 +cGRDDaQqcMFbiJBZxWHrL5s6xaaZhx/JqZX4kgGFrtWoWuZhJuOscYvE5ODBvc5Y
  27.951 +NsvuKUSK3TIyfcpx6KGy4dpzkXYvhXh0Gk1u/s1Mfm9iGWt25G1OjcaYyKIeeZJ9
  27.952 +RGzFy5bV5+h1zp8/6HUTSF6+KtoUEdP79VBU9y0N32EJHSrHBurirlAF4lofSrkF
  27.953 +HpCR2lp94Sc0j5xhMsGoViif/YX3rCZc8Xk+rRhUneQ53CkreGYvJbNrgVGAcyGY
  27.954 +/BHjAp9vN8k7XlpxHCNpT3hLp1cENVn///pVHQtJN4mdA5gEWl09LgEIANYjHpX6
  27.955 +nmppT5thflO8ATgt3qP7mBIAoqHE5xdxdhAwRi/TbJv1C5Oz1WUPT5GxeqvIPB6J
  27.956 +NXQJfJx6u87nVxF/sKHXRUUTxiuxGRA8zlu6VbVP7TSlhpGT5Geuxa/Q6GPsC2ik
  27.957 +ytSs5F0cB2kexMUTdVaUCrfItCameqlIk15hcNrZ+99aM2E6M5zSjcLu5Rspzn6f
  27.958 +8JWh9dpIMucUt7N81kCxB2kFKe/ztrc3p0Y+xNvqlsvo9OavV1ig+fPhfUFnLT9G
  27.959 +XLOEWhyah6VSGQO00jPTokWAiFf70oQVZqa/QsSp7fp+rlprvdxeTxfUqFARPQpV
  27.960 +yaT8FZePPWa3VjsAEQEAAQAH/AwrZccXPZ6FiqElesTud9FGBhOirkNDpvpzksCJ
  27.961 +0bBc1fhM1yzL0dMcksGSC68Xe4W8tPH1UUTdbygDb530FsYnUBX6gnTJCWedQnPi
  27.962 +SMX8wncx6iSmTY4DbiUYUSLLSBG5rfJN/zrz8mx6Nc+bEIq0ruPzOOK19MsHhgwN
  27.963 +1FY2L7k3Xv6UOsNRY+YT9Sf+8gnV7wTPaHGaqUWEJ2wrGvrswOFrmgFRFnZpLjFm
  27.964 +R0jypxzeYnxMM/di2wHBlOA4JwyFJMs4RDaDNbTJ/vDXhA68VmgwI9Yz2T6sp1QA
  27.965 +onuPZRF1b6e1/zN6o/21Rqd/HHVfpPBDY/Q688aWR8uE48kEANZ4q7tJUnBUAwvA
  27.966 +kY7NUJ7hkP8/o+0n9s+Nk6R/jxIiI4ZlyorOnBuBNxtvMVtYRKRuxihRh8VLv4oj
  27.967 +s/LTel1SeP0OadZKDgpJuZf4SerocIR7+JJ5MbyaA5qrFx8pDbcp22OIL/Hw6o/p
  27.968 +7U5U0zhX7vB8If5N6rGa/AQW7ryJBAD/meIUmYU2YlUBeX4wAR/NIXBVz4C4reSw
  27.969 +RWPmq86zamUc+tznSLasG8ydTbJ2dd5am7W2BIWqZHorrI0rS1wTEXS/efS5W+1G
  27.970 +gqbxeWGcKrRu8whSRlUWsenr2fVGr+mFOPasdbMPNDZUhGoJMoIlHnI3HecSeLg9
  27.971 ++Vc6JnYzowP/fDHFpQnnX8mo52EVz52EWljZqHpox/Z0T15yq6d2vnuACLd/yOF6
  27.972 +WYg7nDmzCgxpoF1C4t09GzUDNG67BOJP7fPfZYSC1WzHux7eu07iq97zwrJdcYx2
  27.973 +tGd0Aq85SueLxeAczFNaFEIpaIpquEG0CiQVtRfTtZPMT6YQDdBJyapEU4kBPAQY
  27.974 +AQgAJhYhBKvftzRxY/2lvaRA+aKXVQGGzRfMBQJaXT0uAhsMBQkB4TOAAAoJEKKX
  27.975 +VQGGzRfM/fwH/1IP76DFiW1q/dA6Fb0kbpwrfQ6y6nUZ9hFAItPQnddFGeJoRJvh
  27.976 +FFOSVexJSHI86+Mom8EIY9ALnaKInsPcX18iQg8E9oARj3pWDScVu5Sx5aswbjya
  27.977 +z6vMX7UuMU9juNT3qhdZKZaCGWozIyOZTPwuTR8W8UR+3PgOklrGx5UaN0L9iqNW
  27.978 +xqKst1Ku1tQJ1YDfzQwdQ37Z6jqNyhmkjAil/1faBztmpZ+fd7iEpdCLKBlEL1/o
  27.979 +qQ1J0/OUGquFIgi5dbneh1vWUoVo1fqfI6P7YcGzhDYiZs+99a7q7KlkFV2jJFy5
  27.980 +1ep0xIdhRg8wT3Ilo2PE4DZzIoBgBQuCcP6VA5gEWl09QAEIAO2Sz9zvjza/8iW2
  27.981 +RBf+inH2nywR8+hAtwlQ1vBM4+1M6H5mChKSkD8dqrsrkAMfOSSb8VsjIZ5KKUK1
  27.982 +CVoacPwrscudEYwSC8jCKCl2YgfzyM4ue/7LPJMVaCfXuiyfzoA6zMYU0juvVxiI
  27.983 +oiTOlxZjHBL+XGPG67uaAAvHuuwZw7MjtC6S0IkpfvTrCM76ZwBF4IvpiP4H/+6s
  27.984 +gVqmVqLyq1ZwUHyIdB2L7MWj5ToeFKgzoAuahts3sGk44e11X1OP+ivkT2nl77XG
  27.985 +0udeQDzZAtWNyfiRmu9AYcL2zNKYS0hmwj9N4drPJTGMZm2flnyFpeF8YgH5g60s
  27.986 +5utsc0kAEQEAAQAH/i7HeD+IOjptHDiZxZm16Lvc9GWgmVbTm1btwIzrjvvUZ3kw
  27.987 +DW6vxlBvPoWBY+eBd+aCAEnSRpXdA3fbnt5Lk5DL58Pwhxp+GSzsMi1L3qyzL4iN
  27.988 +taOrkB9kGTCzNTkBNI+iRF0Cj4zqDyvJB6hYt35UgJwq0rVg31z+y2CGcQN5BB/X
  27.989 +Wk8mfxVH7ktoLhz6dbZDoohJo6TkMsJvqpIbZLofsLjAeVGMO8bb9dAJQDa66ZZV
  27.990 +RVD/WcUoIJ+xI453fYQKdDhNaC+7xo1vHL/6KTSHV7ghqLNCrAmFKhVbDvhA+VXW
  27.991 +nrQylwVuWkHnekgVmuddrjhPIP5f9kPWI8PmAAkEAPFi9jdU83Z6KM1VwguERfIa
  27.992 +HoInz2qIr4sgX2Y6g+bkVDGGLVovxC3g0VlfPNiBwf3FGTd1Sm9Bn+6DLw4EFW9P
  27.993 +k5BX1hweCJp3UqtH18r5FaAUaGsey6H0Cg+YsvfS6jd1unqrOOKcAtBs3du2NxwN
  27.994 +MmSfky1F8zYd5I6P/j4dBAD79MEouhBiYpSBbay0JVQejK1mB7uSfY/Fi0UZ5mqc
  27.995 +T3fYJQF8Od6zvcpX9x6qZzg50SmXcv9x+2Bkz+nsXCMLh8LCRWrdNNVXrgyi4AfH
  27.996 +VLbBAWnqDkmDQjBO14H88kVFc5cSZ/xz+1nw9UAmPtWyY316fYwPdW6Mkb6RZAjy
  27.997 +HQP/UzlvaYUvIuwJExJTPFXUMqO3/ACkld3jvjv9Bzu5sg7ZV2DKSECMGeNm4YC4
  27.998 +O707IFx+YwMaf3J7X9826k0a/nYoZbrWy8poqgWzqdyZG9yFlm5xhnQpOMUy/wg9
  27.999 +WmT7wEGPl0OplbR8C1On+datSIW+KMVSzbyR/b1cEVCrVOo6F7QxcEVwIFRlc3Qg
 27.1000 +UmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgA
 27.1001 +PhYhBCpeTdqGcjSFIILmeLxsGX3TyqCGBQJaXT1DAhsDBQkB4TOABQsJCAcCBhUI
 27.1002 +CQoLAgQWAgMBAh4BAheAAAoJELxsGX3TyqCG1hIH/j3BEDqCQZl0eBpIgl7tMnFT
 27.1003 +V+hKDMaZqGSrLJ2Eir6qClTDcTNeWKhqmZ6eOTHvYWcRb6d9qzPXq3CRK6KLaKd/
 27.1004 +uSWdGe/2QE3A4szgFM3b/fGibhvlBBuErhpbOb/QROs6ffG7CC+zPXFzA6ag0HFv
 27.1005 +s4+MCKeB8X3HQ2yIFloM6Gfun+hEedCfgNiLV/1Gi9UlHe0fR+J4nV/LZjyRrEBQ
 27.1006 +uCJc8QnKtmxqbPcVRFxaJUEtkAWkb8sDymOjJ3ghsDELVmxZLwBWeD5P616m2FON
 27.1007 +TCPGvPwZympSj3y/C0WH/GmXETjk07pvM3OfPd+6S/E0d0uFFmd3VDcE5e6eP2Kd
 27.1008 +A5gEWl09QgEIANK3/H034YHxnHCT/2yDtlXZriJzmDIWhGgrbOhTkMZl+6Xgutpt
 27.1009 +5nIRd6otnpPTcgChcvHKFgIQJ1s8Nyg0wVztFgig/1vMwiPXrb28wUapuKtKl213
 27.1010 +J0Rd9oHrs8GKLSj+iPC7QPVMguOETWmbbiBwRbYqgP+BhlL7FYyyB3wEv4Ra1UBl
 27.1011 +9iEo0fb4j4irHw2dtT3L650EMFavr2EfH1AlTQCDlK0dqYAW7A7LMd6I28Av2nf3
 27.1012 +macOBSOEHO7RZirqw9jt+2zU/mfADGWFBm3+uAINeMnFZmqups6eYBqfk3/QSQSS
 27.1013 +qs1xf4EqnYt9/MfucxGPPvdhZXlnmESfjiEAEQEAAQAH/RDvgx5ARcJXHBrrNinv
 27.1014 +SxIK0QVJU5fg+erSZKomfzoG28sY7QOdthoAX+UATiC065Jz52RZ+NtZF4SsagVz
 27.1015 ++f+BOZZfdC6ZXhgZ30ei2kjW3rX7pICChVgoEiYefr/FHnyPOovYjO+6IsHs8fjV
 27.1016 +Kmx2gY/SyjPe4eAc+H4ql9HmfXD33qVEAQzWxvcsU+PqMQJ92Hx/kdbn0cF7ycsk
 27.1017 +rOFWiXw0fbWQAu5MgKwyq6JYsU/fIvQ1vhpmvTaDaiNc2iemvpxnh26BQQH7R437
 27.1018 +rjLrOCnXNguNqOeiWZj6lQ8sCWNt5v4qdYmRWD5WcPKQnlSGnlTb6UDPx9+TKuZq
 27.1019 +LL0EAOE6Q9u6MmWgFDY/wdPQyLTdzEHo3v3+bUbGteQli5U7OjRKdKtfDCnfal3s
 27.1020 +5XYfiXYCOd7KOnprFgewg6SXsVhk6RuEp50o5IZ5IEkPHKHUgWC6fRj6F4BUJ89G
 27.1021 +NwB/rv7FUFkM6t0Y1WLol1yTkI0VoBX7d2oHel4bYnhYymVNBADvgj8jjv27/Iz4
 27.1022 +D/J7BFgJKvokz2/SZCyQGGZoBttJiY420hQdrvI2ELSTcdG3qaU4cRABhLV9B48T
 27.1023 +nJlgnwIjZroKpOxmvqzZnHK0/8+/tjSROP1JBB+OnTDqAo6FS8lR0SuzjTHWChtZ
 27.1024 +bMmspXh67cLh2CZh+Ev9qn5dN32SJQQAt1rpL7SY5nkzjmJz5UakWqER35k91HP5
 27.1025 +G3L675SkQSpOY3vQtWWcmfSXPa6v+uJh8d500euj23PCVFmBam2UYJMAwe8CyLGg
 27.1026 +GKZ4KO2VJV9zHEzlZvi2EsI3F2Lio3iDjD4ubw2MMBN0IuWitYo244EqC1TCk5ej
 27.1027 +n4gVX6Me2wdED4kBPAQYAQgAJhYhBCpeTdqGcjSFIILmeLxsGX3TyqCGBQJaXT1C
 27.1028 +AhsMBQkB4TOAAAoJELxsGX3TyqCGe74H/iiYWaEc9/FO9E86Zo4vqEqpNS6emb8C
 27.1029 +zBc4jtx2CycXsVEPF1NVIMcitVFiwET/P0Z6+N7gHTk/g55uwpzAOYSGL5K27VcO
 27.1030 +8xRUGzO81ckSfhLxqbx9O6ZCC4sSN8xsNwg9XiJB/eEGIw/+rRxN6JgLkpIKp7kq
 27.1031 +wf08PWf751KGt3YK7GSvRj3s+wPwXBxmWXq5LXwVoX+OJqa68YGj3aVpfeYWUEYw
 27.1032 +TLCmyUlxIGU6tV5YtpgwBbQjHBp3g9aIP9N+tCkFLo7C0CFbwQeljv3bIfRyadrt
 27.1033 +4g2b2jUFKOh1muON9Ll3qBFa0DLEZKCLp6Q+R1e3EHDh9hvt17USpOSVA5gEWl09
 27.1034 +YQEIALUUb33D5Ix+7rCNooPt6WHrSOPiwh9jtXauuEaKN85wsbRYDVVzYc6jqh88
 27.1035 +o6DqrC6EIdaCbyS3vsC7EBcCChsD+9yO+U6U09+zKhVRidoUWs0YjyqH5vmGJhpA
 27.1036 +gtG6uCZALnN8T0EIf6eJEgPQ0EXKI2RNH5X59doU7muOCozFfEQu2YrBpN23ykx/
 27.1037 +xXouhWkMDuMi0nzueXXGclVEzUQs6NGK0rTvBLgO7PNl1o14sswADOTcyWgl5kZv
 27.1038 +/Ci9kJMhKfTarqbCwqSHV7T+unRrvoxoilHDFflQgFKmdS3hQKUvU0QUts05P8Xw
 27.1039 +O8mciVYYbzQJA9tT23zwAaa8RCkAEQEAAQAH/AoAx1PsPAuNgNlcnvX+G4le5QI/
 27.1040 +EY2IWuA5MKbSQIOf8sEiqBc+A3uAdl0OuCn4ghXOaMwfx8yrIIInE0bMxGAlAoch
 27.1041 +mCDA1J95Qew25Trt1ZeaMWEebCJWncjkzWqROlZVRKZOigDusOvsBNm/HEeZWLEp
 27.1042 +bYLscaoKw/efEMghPNgVppaleUUIA+tE51jSznyamNDDoyuvjyJgeCz4VS3VgXFy
 27.1043 +urI81rTGUVMZFjWlQa4F277l9tC0ahribIIK1Snm5i2iLIt4eXX8cCMcRULnPcYf
 27.1044 +vmoroLEAvbwCH3IY0U0xLGbdHeLWUaKRKM5M6qYfDtPAK0a5pN0P79lecW0EAMg7
 27.1045 +/YLmQ5op2CQwaLDaljLGzfruWNJplsKieomQABJuiklGx+FDzWsLdLHKggWMZs1m
 27.1046 +xFY+M5tHyIoRHMN4pn2e6Eu6r/6g9W8zXbNHXWqFbQq8KvDIobQnUDsxkaTBbRPR
 27.1047 +1xbwHs2B6gpeIl48ujqS/PaNYo+r+mXrpcuKxRNvBADngsuhh2DYA4Wi6Fd6m+g6
 27.1048 +igeTotNi0DuVaCYuS9gVHyCEgoXuqbW+zTjyxMe43P9ew55xgx0Gt113yc5Ng8zu
 27.1049 +FbYj1zFMXiqxnv2ysmFWx8LzQ16tpb34oJ0aiAYrFYfOBicepmW5Zutsr8GPDSaw
 27.1050 +gbI1cPTrGyGsV76h+Fp15wQAvdK6L1IUX0QzvNpixyQNwW2ITGyagiAW+0aWl0ds
 27.1051 +NT9Y8u7dAlZ+5FZgigoLm6g5VsDodAnrtqbZ/dA/NbAKqGG13F1X3kWLZjyS70pK
 27.1052 +xaccuBD/pJSy5xINxcH5eHDZTJ9UEa1SPuAmc4AWSUC+ZPa3ExzffB1JCGmf5hzH
 27.1053 +4iFBxLQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhv
 27.1054 +ZmYub3JnPokBVAQTAQgAPhYhBHQIXut3pl8GiQI2n6Iyjf2MyU9ABQJaXT1jAhsD
 27.1055 +BQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEKIyjf2MyU9Au+0H/RNG
 27.1056 +PMwHcL/Ao0ZuDjM7dRl0KvAC0gRgwCrjuwuEX9pajTqB3gWmT88jZx1cFdCO3v49
 27.1057 +vKfPUAS34OMq+Y0A66l25vGxhPrGIgJf8J604FTT2BfFxs81mUNGvaRUUbE1IM+6
 27.1058 +6oB1fDR5oYYrvwFclC95MMuks5C0TRyT6jOqjoNFYR3Yj54BbMAXlZHwl997yL1N
 27.1059 +eodcfN4CAbRD9m4dQPJx++HEM3cV9rRVibXjHSsG6wzU1YOi4/OCgVlSXm0Rcxnh
 27.1060 +76ZIgDZFeDwb+qI4gAvmZ4034P5YHHD2Hw+Qahvtztmm07nJk4PFKxA4otvmslya
 27.1061 +ViDVAt9PKXrufiG9rvSdA5gEWl09YwEIALGtSiV+kfbq5UyF/Vs0GiSOKGCaVs4P
 27.1062 +fOi1PLLOZ2vU9jeUabq6vemvI0tb1CepKWv0DLtHvhnmAhGd1SP8RIm64rhqMHXJ
 27.1063 +4rDlsnVNCKW2SvDSFjija0w8eDVYpu6tWPDfx3YDVjwg3Eo/5Vor+BeElLubeMl1
 27.1064 +xZD9aAeo5K1Yb1hBVW7Tea7nEnncuzbgo0/8N2qpaP0vPUgaOwxgSDHWAjBz9F2g
 27.1065 +wjKPy+EhxMdwUkG2QZWXUBD+mVFrqWgj3fKbbkR/+V56AhJmT9/fLhcEjnGSOAN+
 27.1066 +Ak/iTYeGTOFVviZCAEeNG8OWm0+qjWeOPNtg2XhtiEAvPIEFeYCV31EAEQEAAQAH
 27.1067 ++wf7J3ehspGrjzatw0VDqXPSoKBC0x+rUG7tSum0sBxQCeotgcZSgoiGRnaXHqyv
 27.1068 +sCbH9zneZGqqQigabHRuW4HKmNxGYNe+O2Yo0hYQPMgzq+uIhqImGstU4S1zIdta
 27.1069 +gub5TTf1uPvJmhcKBkyvDcsmXQdo7AA0GxsVMmCpIjth7RGH1BqCJ6MmYTPNYvip
 27.1070 +qD0rzmRWekGEjX0b5GO9iaeKeeQgs9+6nqVhGrtcSVJ6kOd/awo/2mGwlRTeGJ/5
 27.1071 +PAIOpViwvzNh8t/SNi2SX7SCAf47lJiX0QVrjTJ7dDg0N77urSQf46bJqeW6xlgW
 27.1072 +mvyXukM9GfUmthy9yqp/qIUEAMWnHXVQg+a36fRWQBpiEHC23kh2bn1TRpSXcgAZ
 27.1073 +bQb6zVQ9xvmBHF2NSmnzjCcKdVkqDLDKZhItVOW0J6dxfw9FduAXQ/fD9OEW+lUy
 27.1074 +6mcahGr10FdGzGKB0wrqVt8J+J3/Fjw1zKoYDuuQ9pGI6ZnTvACemR9BbL+9GBDr
 27.1075 +cIi3BADmIJIWJ2HJMHsRgGW9CiCuoaj1ozGwOGEsbYC07L67v40Ijueqda/HXvdh
 27.1076 +qf1QOhbd1LY6PztsZBULIdpYRaqC1WkulwuKlJGg+8ZLUckmC3ILb76AVQzquDt7
 27.1077 +Yk5QSrwtlOQg8sQnMpcE25PjkeLR1bQgojrrdsgqpb94YluANwP9FO82uZgeiNca
 27.1078 +hV2VSe9MMkbTxaNCIM3cVZYyWbU10KZRX5ltJa7nw560xutOiHpjxdPDmN5lp/c4
 27.1079 +59LZkxlFno0/U0IUw99eAM0UhuU5VdnRf4RLqKXOgUxwjZC/Rbyb5Lnadh43mbwE
 27.1080 +vRERDQDW81POiiuojXvN1oZS7wJESY09xokBPAQYAQgAJhYhBHQIXut3pl8GiQI2
 27.1081 +n6Iyjf2MyU9ABQJaXT1jAhsMBQkB4TOAAAoJEKIyjf2MyU9AjaMH/3FTivnCuy89
 27.1082 +fr1oAAmm3ay3S5+i+aiEqevByqs5w2porvUFM5kc3U0m2CsxFgawqhhjJ0soryFG
 27.1083 +bfjpMzCiqwTj0iv+MS8x+Os8JKCLRitqLDc/ACqUMK+Dh9uSEbhwRqQMuY+3eHVE
 27.1084 +vtsGdfffYZ1KV76E7VcZxmwxhXwMnnJgqMGvs/QSIgEX2Ak5B83IoiLNDQ3eluu3
 27.1085 +u8wYFbXYeC+9L43zMKTua21Nnc43JsykP5LZQZNThJr4KnPN/lpZohdJMPdesVYI
 27.1086 +YgKmSVNKwzxXzgwdAB77v1FT56XGov15TqmGFJvzqs4l/udPwvkmzEZD6qSI3moT
 27.1087 +u7PFBLx63DmVA5gEWl091AEIALBdf7x7dCG1daje6hp+vPBD63LJHNGRJgxrHTtc
 27.1088 +Jvp1tLYI8TThRIxDTzKSwAORSqGs6Au14KqXrPFtVjEbpmieYLADSMAbTYp8j/JI
 27.1089 +Rkg9BsqqJenPDUlhveq16uNaOgSN5Jk5s3YR49TVeqPOcDgZ2nshLCNuY7AEtGpD
 27.1090 +RUgBpRwDWFyt6etLkhjW4iOj6Fpa5SlERHNn+MU4iq+8wUWAKefA44NWN8V6hJcv
 27.1091 +q1EFq7xddL67e91tqy1dKsux+LxjOSHlwEYpHQc5tspUx6TL6mqnjO13fBIgA7Mq
 27.1092 +KQ8njLv9y2JuQB4ZWrOEqwyq1ay0/GDmvhTCzDsY0CgdjCUAEQEAAQAH/iJJ00tM
 27.1093 +PyxMkLcHu8Dx8f7OXai/4+v0ic6xRoojZOqd1sfrXiXXRBH3Bh9Be7ZV2YosSSL5
 27.1094 +tdfEzFlV1gOPKh+95vNheBPtWvp5NC05Evz5bGgbg2p9GEqzh45p1uRjxtLa2V5W
 27.1095 +4wap/L8E0CanvJaTpC/7J48t55CxoXflY0NXx8lKZ8N0TO8gd4lTSSN9Ad9tycxA
 27.1096 +68JA4aabkNV8mHjV5ccbG4wslFaiXMb4M3O/x5GHzKG7zPLXsSSQpxxP8KAuivX5
 27.1097 +Pa9uLRTrz3hFKp7S9h/C8ISW1YxZxH2wtfycVN6xSjXb8H1GK0Jby+DhhNmhY/7e
 27.1098 +lXDs0mzZBd85BbMEAMlPWYJ9qb4YAddq/+xkIH+c8OxOGqL9wc+v8HoTvyfXe0ZB
 27.1099 +LjV+CeW/qLPgmGU0XgMjP4GzU4LDVEX7XHjPperAfMyimFCD4cUVbiQXu6g3OfVE
 27.1100 +Vx3sjN1jVgci3byf4uLoxi5y2FtV4eIU0V1UY/Zi2h+ufiEM3NCXpcwA1/qHBADg
 27.1101 +R0zRuZqhjgsj0E+P1jv3JFnndKt5UAY4r0VdG6AXwi0kFciVQww8vb8FauAUA5Ne
 27.1102 +l/wFZdStHJ4utg9y/MJjogvKr/sd/eTX1kqqg8/Dwl21ua+7y0ESfQPk93dLxNfL
 27.1103 +1HrVChBEF+rzZohXrote44CY13JC44G84NSywajS8wP7BfW8NXLlR0I+1ttCDohp
 27.1104 +VOrqD9VA8hcuMCi0O/eu0N8hmaykKUHlnzCO2gdzMQh69/4HUCZEVy1P5HUge6pr
 27.1105 +qL4pl/jtD1Yz72aCmFzdRpXm7GDoi3fQv8C7R3PQ19bNcYI2/cz5OQIDvDMyXvCC
 27.1106 +dysGemdGUMVqKstdT+n2WyRXT7QxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVz
 27.1107 +dC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBKvqYkJ6kXQeKoCft1k7
 27.1108 +e0NrbITrBQJaXT3XAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJ
 27.1109 +EFk7e0NrbITr3D8H/RVYdg5oO4OnuvgTTFrDbvFI9HnO+WCWEXsnARJCVjVhcTrX
 27.1110 +0/xW8h7SQJpJlXmxOnIa/Q1InA/Xu36IyaHntgT39UPY9XCV28O7NnGmWMh2w3jN
 27.1111 +Rr++wUgwCtlZn1oZ/aZlHfFTx0rxN0l2CB8VKeILCwDh+GopDu0+nP8zOnbvedyU
 27.1112 +2MUtfX5rrNmGwpqctWFzos0tOdFX/IVKltm28aGGsIl/K6Br2A3Xi4fRFpiRXunv
 27.1113 +vUhzPLsbRgssB6g73Ds0b9xA9imsHPsqV6YJvFa5yyyeMFcIVeTR+a3BYgDpwN4C
 27.1114 +bO/PVg428s9wgUKBjWiTcqmIt0LAwP38iLR0fsadA5gEWl091gEIAPcFCRq6O8wk
 27.1115 +yQ/ZRxFSxmZDaJcIXPJ2xA/i4ptJw/P+z0sSqB/R5HrOgnsLR1UxC9LYFXL+wBFI
 27.1116 +xOfwHUixbiZUMlpMvkEUPZkMCJSAfTpWbxkqjzgoCzAnzmJn6kNddVFUFE+OZ+sL
 27.1117 +Gii8CBgxtTs3kNuIuFTZHd6vEhKC3A34LZJyvZ2GGvJBRJY2lyOuooJVsvXs39rJ
 27.1118 +NtlmwHn2ldRGET/FgSYwGynMsqGjuSveT6mGjukr29O4wsGDL9QgyCQfc3sZKqGd
 27.1119 +7DlU3xcSWuIOF0Vx9jEfWeSXvZlJIKARe4Sjlhqpcq/9ukoWQ6siyJXMGZ8W7QJG
 27.1120 +BGEFC7aHyBsAEQEAAQAH/2GnvvqvB3bkUAyQ9HSXydGh8pZK+xvr8gTpyHZlyi8K
 27.1121 +3H6saITz4KTgQVtNkSzP0AHR5WDp75qlrxqWpa0YYBiNDr7+OfTWgKehxz6WMWu/
 27.1122 +wfosBiTIR+wIwKHMvSNWrkuxtrng7ZpRcE0MURLni+NWS1FPEriQgSuJANcKnt5y
 27.1123 +KRIHbKw/hyswWUq2FsV5CB8Hu826VHwn6LPcKPWou0Mjqbcj0yzRPGAk9rJ3YwKF
 27.1124 +pwoW+agDgCdm9oPWEPlZyJAfsfT7/xxU4tekcHWF1ac8aKtDeEDwN9gNkaDwinUr
 27.1125 +o3bKWzmkIFWvaVD9VhNUSifmJDLXWmmZFz6Vfy8FTmEEAPi/9ShZTufC80Drk0S/
 27.1126 +b35mY6MnDY3cBoLzlKbIv6DcUrVOZhDOiG8bnSMVAGZYQPUK4eIW+pGl5nFAgjip
 27.1127 +2WOyI1/d9+Zh2S57aKy4BbTtBGr8igGb+re8f9CGK+3/VDU4i3IRmifOPNPznEgY
 27.1128 +JKugpUBQILvn22GeFPEM4gGLBAD+OCsXfOjIRKRbed9udQu8T7jYE4CrrYRqfHQy
 27.1129 +FGaLFn4isiF5P5xvj9FUaK5gGOvmeWSKrugpKJVnijoEy+P+Nc712y5yUdmtPucq
 27.1130 +nYM0msvhOqCFvw/5lqyxjtbGGcmM0lsDcFl3qcgaUP8BpO60SgOzvfdf/2XLuGhY
 27.1131 +WlcFsQQA25Os+ZY+nQIzJDtD/NrMfkYLg7D0Mz+AF+klSL7FePtg0CIqfcQqCvcT
 27.1132 +Lfpn4RP1ESjOKnFLz9bHL8UbH9E7+IRmsfWiTswnAlNErGBc+qwCgiA7IhpsQQHl
 27.1133 +Vz20CyUG6InShUQXT+Tokrs9K7lG6vS7PwRoiR66+EigDPccCrFBNokBPAQYAQgA
 27.1134 +JhYhBKvqYkJ6kXQeKoCft1k7e0NrbITrBQJaXT3WAhsMBQkB4TOAAAoJEFk7e0Nr
 27.1135 +bITr7BAH/1yGx7ByDOGaYD03ZoBThXw3jcdb7W+YOo3Ms6p9wTMGfbCsAEqnrEze
 27.1136 +6whU41vodpUlhdVGhxD5FCiI0KRBvkvH1RtD9Ka6NC1ecSih4WAVlUz7trW8c+lf
 27.1137 +khJqoJIkFc2fZJGopH5ytPISopm1tZU55rVzYkKtXBdLg//ce+MtuqXpbVRbkCxB
 27.1138 +vzIugVFsPOiE6RUUhU29zxNOEIJ+ZsUxKcACtSvDrgFvG5gQvC/7HEvjaIYKa6l0
 27.1139 +XCuxh8vBg/NkBQJuLMrCXG68AUHvU8tA3cXCV4mg9BdQ4f4aMi+VNKHPGgfKhZcP
 27.1140 +r0C/ItdT1OQA/ROJk67v8SepMcVrjmmVA5gEWl095AEIAM5aBmfgRPQfzZtqNFkX
 27.1141 +rtRIFIL3dYy0ewrfVKkJt7t7GRJ0pvOYQxtMbywgm+sNtEMfwVp+QwOcAUcB18qW
 27.1142 +FzVn5L9KjsptG5ad8ubkNqzw1bihGi4Osi6TxciJLj75UXP2q9lRPMsTpwx/iMkU
 27.1143 +leWopt4M7VgcqPNtRIppQUwYbUhlOMYNEAG71p6Qsa4y5SfDwbH/lyIKdnv3CUsO
 27.1144 +1n45Fpig3psF1hd1lCT4AYGfzQzzUwnypg3+BzUCpeOxMeAU2FABeb6Oij7Ciqjn
 27.1145 +HJh7dFXunGffic7zvks824a/V+a0+zLlq9i1Gfaj9r3zwPYmP3Ksd9GJZ6gaOceI
 27.1146 +5OEAEQEAAQAH+wTcihoYZod52FY5AlK3BB9sM0+ClPpjpiJzcIMq/3EjTUvqA6Tp
 27.1147 +iWszOctIWWQIRp7uOJfxMZL8MeuCV5smPhW8BN+c2hBa0bOStQ5Lgh5A7kgTQ5Ki
 27.1148 +NgBy6s32rWg+Z3Tb8uCD0XLXW7AnsQlLutxWRNgmZdEVm8VgZaT9JdStE9F92gHn
 27.1149 +SvM3lPy0Y0bP9j4YwYkVudEX+TzX0IXlUhpY7ioWXGnZgNInLPD7siGJLB9Mw3eC
 27.1150 +OrK4F8NgPfoUgvEpmokyvyZfPuiphUDZfExQaQ5aEIkADuGLxOkEr3p8Kuu60TTq
 27.1151 +6IDYI2I24h+Noo5hLaae3uwwPO60gHB7XKEEAOPQ7+1cfKJcOjMemuU+RBWoh2Df
 27.1152 +PPUgtFQQ+U/VXVEXSgUw55VWSrLak6nNizd7pANPK+aglVk6VvjCYDqo2meOGf4V
 27.1153 +0NQtQH92AWglzseFbHmoJyoeT4J6l53UeT0ZA5uu9mQ9hN3+6fcIZKPOSr0ellhX
 27.1154 +cIms9fKXbVXlFO2DBADn4UuYYrdqk9fSilf1Bpu77CsyF9takvJEGzstPQPCeQA6
 27.1155 +BiT5pefLFmqv89ZjBW+TR5SPhEZijjc5pQmn3EASVTSaGCdN1ouCLX3VL71ILM5r
 27.1156 +oVLn1L0lkkMuQsTc6Hx/OB6Zp8NjHVW1xhQov/Lx7tGORO4UGhqRGGVns2XaywQA
 27.1157 +wP5+XunKALi1sPBRuBTsyEbyFuqL1z+4srZg1ZePEVs6ixE1/S7j344TBBIuVzWl
 27.1158 +4mN8aKcVYas2Ebph42WfEJh67F5gjELYk6SFzzkMZDROMvb7STWUpdpj9MIDpTnf
 27.1159 +NB5j9HluaZIn+K+gPKLfO35OGo+Efd8ACMeJjyvFuqc78rQxcEVwIFRlc3QgUmVj
 27.1160 +aXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYh
 27.1161 +BAllN3DxhBSxviFclZuTV/46XYOBBQJaXT3nAhsDBQkB4TOABQsJCAcCBhUICQoL
 27.1162 +AgQWAgMBAh4BAheAAAoJEJuTV/46XYOBtyMH/1a469CQgelc27UYm1m2uq8RRpbP
 27.1163 +Mt4vGADavGHQoOXUU372xrPJ3MvsG3eFWVF1UVMR553FC7trljSzJWB5ZTakj74O
 27.1164 +cpXLSeyxnSezqjiOJF3JGc8VLBKQdVlsjWHOceH3nz+7ivUVGj0QwdV3DiVyTQyo
 27.1165 +iggkzWe78G94QlWyMWRgUGlL5iLE4KYGTaD5bmqn+/HcDqlxEm102gIAKZANgpyo
 27.1166 +C7WYNvAwTMp7NC1mUvOWzQaNOdlk7WvseU4COpDXWn9YNmejkJaMcBf3w+WNnuDF
 27.1167 +JPND8OwFDypwSMcQkMjqDgrUnvtU+SXn9jNK4abqN5XttNOmKi400euXf4edA5gE
 27.1168 +Wl095gEIAPQ8s7EW5Pf92vbLt7n/JMTQwg9vnNTKfkjhZeTPHd2J9qLU6UYJvovo
 27.1169 +zNXT0Ynop4NUGS8QU08kqHF9LKK4/HifqyVbocxn0yym5S7pNe3jvVTPFXBeTrcB
 27.1170 +kpFOsWsFnvzmt/cFk1PnFWMDxu0cD//qG+UeS1ktQnGZK/TnUhx4eSFcWU3qdavQ
 27.1171 +U6/JCrW3zQ6YOkYFYZl2WhC6vX4yQ4VQPoxPNjm41e3YFUcmJI8Z/j7EOsoIbVTo
 27.1172 +PqfC5wqfbq/Sk7Ibe3wUMNvGFQpvbLYrI5yE3j9+nV74IfT2uBlBAuhbW98I7XJ4
 27.1173 +BvCnkcg/qeT+btD37u8mSQw9a05k0zkAEQEAAQAH/Antys9M8zd6sDNewkQTMYM3
 27.1174 +yl/WxX0oEzyyvxHvcpMeR/LELYyNmlu1NdiOgSL2XJL78P8nDn/16Uwdztn5o7fi
 27.1175 +o9JDuJ7m7KCQ01nWHL1kR/7h4Uj9aH1LmNID7TYA1z8IQRvPc/cR+p5ZGbXrcWIR
 27.1176 +uhsVIXKJYr1cAPu2iLHEBrCJaYP2riK66rrEPskr8yQP7TaXHfX7QEw6B2M4Exp2
 27.1177 +VwOXuc+a+Sfo2yYBqodEG84zXZbXmwJ9oo9u5RdFsq0h4m8PqSTa6jM5oHDGJ3JD
 27.1178 +acuMJA3GJ2iT5TVeTrj5AvFcmB/g2PO5H4ZVXVVVzGKvgHoKcqDZO9iidLWcoSUE
 27.1179 +APRDfyKsn1OT4FYpopXq/TRCnJH9ySQAV2rljrH2PPDQqU7P5sTY9E4J6GSccZJz
 27.1180 +a8jM3vqmWInXPpi12ehQEIMlV5FEyUSY/nR/0rGMLm4gHFWwy+DvfdxbxZpH3OSC
 27.1181 +3jNYey1lj5G7d/pop3QYOyhFQFrTtFRAkLVGioJKUTllBAD/+OD60+meiO5J5Udi
 27.1182 +kT8F2r/8HdRE/MRMHGpSkEwnoY9r4w9a+15XVGGMNwjJpylo2IYrJf+bapNTvGTZ
 27.1183 +VbYOdfvtjq2lQ/uqtri8T6qlIxRAb7RRziUzkvZmZ5q39aJCqZl2eGt3SPknp++e
 27.1184 ++kGYteCbFWnIV8hpoG+j5ha/RQP8CT0I96/D0Ee8r4ObBgp3h8saAcOx8CRTy+Jz
 27.1185 +fnx+K1hJg4I/Pv6Ko4WRZe4UlEJ4eiU7z26qxUYJmaZ9Xhm2f2yTd94FWDezdsnZ
 27.1186 +1WqQqK0FweW7/SRj6Rhvtynz+chmdEjyf+Uqf7J4VNb3JsQS27/jriwjRPPBOK3y
 27.1187 +y8864xZQjYkBPAQYAQgAJhYhBAllN3DxhBSxviFclZuTV/46XYOBBQJaXT3mAhsM
 27.1188 +BQkB4TOAAAoJEJuTV/46XYOBgzIIAI6QLoLTUfCba6wcHDorwy7Ohtt8iMxu1wL3
 27.1189 +0wIntSr+zEYwuEO2zcpUQA+uro7PTiBj00bJejBG15ZPEbHVPT0sYSKAJRmc79nF
 27.1190 +T6plCSqUsorETgMw/QSGf/elW0jmuVjsxTeKnpTqQZ2TjM1X5Gii3fttakDLTR7F
 27.1191 +Lo3iP5Gs1TMsphRUl/XwzgzwBCn7X5gKBJOFcAskaYGDPKVV/ffxB+L3XdEgRQTd
 27.1192 +pzq4lyosM3CsbKd5dz3fVEDYcpaQljhOO5aJw7oXZgl+a86FxWKMunN2cEFOJaeD
 27.1193 +Jzlv9PIEdyB18V08s+zxXXFQjdNt/5r16/13bPU5ngqclMiRb7eVA5gEWl0+HAEI
 27.1194 +APcMKxHq+qljF5i7ESBoATO08KpIDy3V2u+wZaC9EXDgCRV7UcN4XcQz0DaNitJm
 27.1195 +YQB5eC3nPU1q+NvBoRZ2HTuMKyhfuVlMwxN1HQhMB3DE40XhJ3za1OW9wBzuaZQI
 27.1196 +9rxTExL+z8q8Dswivzuh4aDAeegvA0kvlsH2jFqGGabdqZLckkGSEtKxSMbCyuzy
 27.1197 +J3B9dc+YEH7l4UlxqJsTxSVSzOWjUgmoLuXpTLQjJzyEACgqRA1xUuDe1PYgoMOM
 27.1198 +k9PHHvmAa16VIUoPztXOZFPC7KHznEt3atPiJbaLvaOrsKe4KKXgFTFJ0RI0fkTp
 27.1199 +SQTy2BCcYV/b4+SStFh/E8sAEQEAAQAH/0woMSLN6EXNaVnI2Se/SBeTgNlNa3h6
 27.1200 +w4o+O6YIgtbkCYjYwkTa1zUDr/0RNylTLDYEPBsSfOBfyKWeFDWjZbGUrT09/Rpd
 27.1201 +Qom+AZwsK+MEnvdMyGqB3z2PeCizClL7TGyTw36IlK/vtzQQxhjw92ghzbLYw0+N
 27.1202 +XxEeGvhQ/JlmgqvJDNRJNSn7Umza2HD445/l2A3gaJ+vUee4kNnIy1c0mOGtD+7n
 27.1203 +RMSxOhLk6/QrmrPUdk0X/7lmTf+DFg7dolSbM0Z4uHE71hPyceFzPrNsekDK3BPw
 27.1204 +EfI91FBlbDhANNEbtEjJgX5doLdT7Zq4n9S8nK9O0PtTJ9qvf/adtxEEAPcuQpYT
 27.1205 +l9NCvBCIPQF+hRNHLjjIfmbgWx1I4HkmugwJL/m5F+bHA2WXav4myUKhwyqPVkYx
 27.1206 +aS1D1xK36EVlawtfdQj8Z71ZZ0gCGeCeYeFNOh9JoufItVS1L3YNfNrjD6UlVYLT
 27.1207 +elW2j+Qz/itSF6WoBLyuHjtKOJ9eT1IBNIiZBAD/3LEXA2n0GhHgkZSB2l6TO5Ni
 27.1208 +vccaJxbxEuWLUU5RN5u/MBFmA8qDYutyza8PLd+nHOMenuN6bjwJLgZpaIAFZCUu
 27.1209 +FMRAXNYR80Vrmed/lUZ4tZm+oAb09HeUbT1oQyHQ3/T40C7AJxF4iFe9RBCe321V
 27.1210 +w0h7Vff5Pus4mZeKAwQA3iLP25tsSOQQygrAGL8E5FAzlhyMA48pVG05y1PG6FZ5
 27.1211 +2SXhKqYkzYu0M4kjtCWvKW1mAIWKCXK93L0gFIO2l52JFIcN9SwqcHIrk5BOL7DQ
 27.1212 +e8Tz45kgPuSoQ2m083lXgXeTjYrmOLOF3pTiomCEugfkQWVCDpmaV4eOZHN5S4c3
 27.1213 +irQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYu
 27.1214 +b3JnPokBVAQTAQgAPhYhBHOuKKWD/+Tr1Ltis5FXmxJzBDLNBQJaXT4eAhsDBQkB
 27.1215 +4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEJFXmxJzBDLNtRIH/jEONwd0
 27.1216 +2tYIyRooWAFunAjsaqFrLxslagwDlyhVNtuKXnrOtsjPUKTjI0zhveBBURAgzcNg
 27.1217 +n47VLo7F2YeS8be7hJ9lfcQLyZhVfOKZCm9dnT9WZM5zOrSAS+4V/BPR3wsdQ86Z
 27.1218 +QvfHbgNPKnB02k87y0wD0UR/iyWt+yURH07ePaiMnz2ED25UM+YjbDPbp6x2MLTh
 27.1219 +Mzn0zCzIjW86xJm1D9oWf8cIVBFKtQRweaHLFrVQZG7IDrl/E/luCpEKikTbHZdi
 27.1220 +immHijsOoodQoviPlfon8itdnO543RcNVCEz4W7WatQw6zQbY3VLien6YAChOqfu
 27.1221 +pHuu1HhTWHvIFWOdA5gEWl0+HgEIAMAiyTdm6ku9jeNkfeVlKawMzzviJ4eQuq7S
 27.1222 +ltZQP/vPGcI8orxvvT/0yF73Wx1yoP3AXeHbjTv1TnNqC/bRVfDcNShlyy6/aRi8
 27.1223 +Z1wv81PwtSlKLCq6ZJSvG6MFt40Oi8XY/zHwEPxyeAKcYTwP0rGZ35G/KDDMG7sI
 27.1224 +h/ikCN5APJDxEoFGj++O4h3kL0oAXzSJYGQx2J4vlmKwtM+tQ/EVrVOY3hN9Cc/Z
 27.1225 +xiQsNja6gISDHT3Ucg2+HvqAuhTUuzYwujCP4Wt9OCzerHi4SudgN4G33EueTToy
 27.1226 ++A6tOC/7JH+15LnWbDfwGJSmRufmoeyfs4uxpNM4s4KlZentAE8AEQEAAQAH+gNz
 27.1227 +PHYXDi2rquDCnQjMVGoSACX8+CUU4hKh68fPwMO2otRG6XcvxyVfBxAUKgSGhUHj
 27.1228 +5+ur2RvoBO9z9TYKk/FTdaLoPQn1sZ9E7Cg5djRI1hVL5IIklF91INkVu7I36ND1
 27.1229 +22ib/STDW3NUjTcaY6KrzC9zpXbxhgKe8xjHEp+xs0sK+LyOtEoUnqvUOuRmQhSG
 27.1230 +Kw9qgkoVuu7gidAMl0Cie0QNFUIwgyYuvAeWZsDG7LzIoIZ1MM0Geb4o1HXkPHau
 27.1231 +QAGeuu0p9hfyrCD3HEcctgPxYddVIW34/eXRYhQRQ8nyvuhVKm6brUoCNz+88+Vs
 27.1232 +QcAmHK+pPX9zCa4+dcUEANLP8dc5NhR7wYxfRv0jyc/HIg1vkDEnoRf6PxIt5/M7
 27.1233 +d9sy4biL6vvzBTukbkbp2rxsSZV8Rq3CpyF/y1cL/MoPa7yT9J5XaO9KGTf6ID2b
 27.1234 ++yKFpbiV192Zh+AM2RG/3QLttN+C3opy/Ine60hLCMTph5eZDW+e2pa7XACWKATr
 27.1235 +BADpUf9jaPYDRqXC/lYfjuwrHppH6mRySsq/GcaTrPVcVat5ed1BmsNljvqQKEW/
 27.1236 +CqtNGFOjuhMO5XphcU1z2F0H+WdWnGj3LrcWnoRS0cjVz7rVr3LzzlzNlFKDeTq9
 27.1237 +Tsv4oLdYJnTCv2FvF0r7SYs+fnA1YigtbDeTEzvz96+pLQQA1cgUyC1H+/jZ0GKA
 27.1238 +hEgXGO0QhvJSLkBHxE1BZKXhoLuTsgmOTkTAuZA3tgVdNjQ5fdkPnqQEavJ91r+h
 27.1239 +AlAEaf0DQS29YnqUqwqs0tB1MXANZ+Iem7GhA2wZ9e3TrpNy/vgH4xk87V8Vf+oV
 27.1240 +0VkkmxK6Kh+5zCSPccWqAEtXBElAwokBPAQYAQgAJhYhBHOuKKWD/+Tr1Ltis5FX
 27.1241 +mxJzBDLNBQJaXT4eAhsMBQkB4TOAAAoJEJFXmxJzBDLNxGQIAL0/xrCtb/ehDWWM
 27.1242 +BTtOy7GlYEQwYVU5mS0zSjipUtr9kvoriFcOu78b5Vo+dPbMj0jbmEURhYbplQGZ
 27.1243 +ZInVChz/hXQ/QwnQaLaLBJHvJ0RBeOJFkHwX48ddRXg1c/JzGfbj39xx/Fsh4wQg
 27.1244 +ANl9P+3BH8kAeQdKg5Co/90FgICxTSJYJ1ugRmzSG9EOsGPGS62L6p8WPxSTPGTZ
 27.1245 +VsYeXoOPeFYETKDvch3jgVlFL2FjwslrGJemKspSg5Yrw5Amfng/0wvdv0E3HP0y
 27.1246 +p9cqyhenGu4O16kzl/vHtm1Kv9fBBK8kMhhq52HqHU6hzScWriDPuBf4heoPkbiX
 27.1247 +4lLaVqSVA5gEWl0/BQEIAMT3qCU5JYO2v+B4djovl4D3bb4gE9CUc4MVLfRin6AZ
 27.1248 +nPcPXcl41y+jtCOXgbG1MhVRGPZMiqaVtA6CP5r4/lAwV2wJ+vw7cJVWoc1e0JAN
 27.1249 +ZsuZW9dY916SCKtiUd+ZkEfkPjcvWl2iLQ6FHTogTebxf1OuIbkqw8elZ1CG51mb
 27.1250 +1qTReqeyElfSjBF9Q0nG0kjtyCzNzC0TpVZLMV9t7yCCWvosNHZKck3j1WUFGPTH
 27.1251 +AyHht/wpjwIaSTcdlkrGTXiSbp70VcIUSFeA2ueP0Sc7Eq+JZ8XBWiaHL34YI8Wl
 27.1252 +K4SmiTPAoOAyAmhU4KVaivtfvUpVGSbGQG/8RLCWSjcAEQEAAQAH/2IDCKlJKAlE
 27.1253 +UXOeDdrDXuT+ep3+sU176YUDb4Qp5VuSE0D/ZQCBwLaEg/moBRIMY7kmy0CYcvAV
 27.1254 +E22a05LGrynw/DeXOcz0uP+fBdG/ihH8kTfj/scIjsOA8I5z1ODqtdiIU4s7ZYCt
 27.1255 +WDVe+N25QHqYlm7p+f79sEFy5Ze1IX89RHL6x3p+ga1cCs79sWAyxKNBOgsb3ctj
 27.1256 +koA5wcx7ouvo1Ju4s11lZWfNm/ez6IjKT+HF7sJHZFnjeKGWAaYkwqVCvEcDW+nt
 27.1257 +7cjG2FRxUInOfoo4nsjoxYJgz0bZf3HtQ4tRBv/SC5w8Wpm44/xECwbd3MT9IShE
 27.1258 +xPTZmPhkSHUEANO/KrzwVk2oj61cXswAAB8dqaE13Hg11QSjM+frD2zyeUu+CUbX
 27.1259 +4N6nPKD2TRsBglw9oYd6uuAePFbxMJOIP1sGc0aSRD+excHxvVSan6pLnGzUKicp
 27.1260 +l4zkue6vfNINzNlW4kV3Yf2VkWVz83fgw3sZYhri8Q5k2OQs9iF2zCRTBADuIcTJ
 27.1261 +iUNwmLfea7OzBAUf0hBcCys89pweOfiu/Qe6RIULytLEb94lkqq9NlRLlMlw5xIB
 27.1262 ++h7xIkyikVv28skhyfbLoDAn3miZ2iONfylEuuaUHD4/Pm8XItS/qWNDl7mhttm6
 27.1263 +WLGt9hxZkdbyDyMmk+tm1tyIyThslr9lF1eGDQP/SdK3jMYF/3DX9gJbAO/mSrhb
 27.1264 +0ReDK1NXwL9TPTgWV4imsXsJI/R96s3eXS7CNLZLv8Yco1xJ1UL3tmLGj9GPCQD/
 27.1265 +8niDN7HXCjr9l97B1AcLW9B9f8uhqqqbiiV6GJCEPz/b4ZnnYTUHZgWrDEvDip+e
 27.1266 +dT7xkgm1OnpfJ84ZaF1Q5LQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5y
 27.1267 +ZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBG4QYWJa2PRg2CmFeQ20ZpZD
 27.1268 +8/GnBQJaXT8IAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEA20
 27.1269 +ZpZD8/GniUMIAJyPOVIPG9MFxsvjh7hhRUKj/zUABH3+SX9gLK5m0QC1lwdVK1FC
 27.1270 +uYOWIzeHZ+AnlCBOLq1Wg61aVSr5oTk1h6sbizWe1cuyC4F4XnltzhOoD6RYmgeh
 27.1271 +LeZV4U76nRIV3F6icFgY/L2Zn2s9a+XtdUUGhF91xhM4UO4a1B4eu/wXH+ZhKLIT
 27.1272 +NxC8Ru2RaFqIErPLNQZhSfAjtAf9Tx6LTqWOxRscGSgri9YM6re57sTZ4bQto/Ny
 27.1273 +81ojSBcNuTUDC9w4/5IyOQQVz3Hx6waU865H90gJ/p6VzbxnCJyE/73jL+YSM3eQ
 27.1274 +YSAtqNoxHR6wFskBgSna1d2NNjkDA22gRhedA5gEWl0/BwEIAOSCc032sIy2qicM
 27.1275 +3wx9IPu+Oq/wTQDm4afaLArI8UuQNSS0FEk8f5DW5CpcI33KNrt7ja2ph6eKeg8T
 27.1276 +7HD28I76xcNPSYLdAKpwpSsOIdWm9tz9tVZmrsXZMeian08qxmgPIoPD430zuCLI
 27.1277 +D5coB4L3Wyb9SKxNWcZuM/a9e25/lf/HKsmXAxS1lxGyzN6Y7X+0b+zlvuKH2tPy
 27.1278 +J1zxtG+x4yNLc730nKQ+4WIRDAUCvfDdxktUHbqPdJYu3ZYJWysUjvHpGOg1cK6l
 27.1279 +avsumYzzt3VTfty5iCc5z7cpCvxnSC77IhygBSGD73U0kk1hyDCjH6n2BPjDgAi5
 27.1280 +ppyECc8AEQEAAQAH/jQ07Z0JWGq9rQBA+5DB4dBCNOxPbXhgR3vu55MLN72407tv
 27.1281 +/RaCYO65eeWHqYAqu/h3kPX1Po3zoFFjjuh8MpeoCZjGu5fPYECQfdvpXaePfuUc
 27.1282 +fdqgmRuQtMtc0DrpHe1WT99k2MuZDl+773vsZFLyqnus8HaVMYaZVPvxbIrg4tvd
 27.1283 +QfKnXKQ/6CuGFJIx6NGE+oZd2HyIeNW7Xa1y0SZRckhszaRKRsWSr988+4v2yUdC
 27.1284 +XMCPew4Y2lALDeueXO9coYn5hJ99rH2sXew8JN0oDzMEXA8N4vSYi7Vs9BO07FQf
 27.1285 +2HjkeM31Yowlji1A/BhuQ4db7gffxYd58zRZFxkEAOyPFlX/DwSG+VxVUogImLXM
 27.1286 +AHcksZa84qkMwkZ9VS4D4hocSuIne9MJU5yWC/+L3VX1JljSRjadhoLceMwtRv4W
 27.1287 +V6X/+hkhT7a4oa45k8A7pha/h5PuZ4AxbXv9yQwS4dE4Gk5dgSX0zQMJTAyAQk2g
 27.1288 +K1WbxgMM4Mb1BTEc9z1NBAD3SgOr6aStxl6l4M5xdJ9pYTp6BAV3Wl/gCB6jHuXP
 27.1289 +xFCfDiohpjPvYD/2PEi0/I0mOclPtSF4BX5LSJr4HE/NIBBY3yR8n0/Mm74W2XjF
 27.1290 +oh/IkB8PrvDvPwA2a2qay54v31UC2sBCfIFMG1foLuaFbmL3HRayVhBq4tlt2cBF
 27.1291 +iwQAnM4e2HiGN7szZQYza8zg2xi4DdgZLTuqe+sLFoA8TZJ8kNVzzD83MVz5jBNa
 27.1292 +8Sv6DxSFPTor3J8Mdot/yuW89Bd2QQre3JxMzFdY2wzeVwuCJ3BZudUmiT0GBu2w
 27.1293 +DUl4QlOYssDwxtzpkg59W9X/bjZh8AwxrGXNY+/P81VHKwFBcokBPAQYAQgAJhYh
 27.1294 +BG4QYWJa2PRg2CmFeQ20ZpZD8/GnBQJaXT8HAhsMBQkB4TOAAAoJEA20ZpZD8/Gn
 27.1295 +0fgIAJF3UOFyHql4qU7nQzgRk05thYAtdS4nqp60tH4JFZOCAKvAG/4DznN3zhOE
 27.1296 +vKdA804swa32V6tq6EHt2SdByO6Mx+gR92Dle2mJ5n+LHaZUOkVcwr+iKpqemrDZ
 27.1297 +2wvfzATnj1wTUAOKgStjh6M1shzxSBQlhi1JrXuzr247BfrDatUoFwJJN5nvttCT
 27.1298 +5/CJ+0YmbJ8E/HEOO3ZfMLb6KDudd5nLqGhr+3awT8iHSWeJc5L+GLTfOFBnaukp
 27.1299 +ViqE87bEPUpHqOxpkkMHjCjf8XNrbCGqhnva/vmVoQo31ypvyptDS6HoFc1F7JcF
 27.1300 +ZTgzfSrMy1QG9Y9RPO2pXRvQg9WVA5gEWl0/iQEIALzY8Rw/OENLadJpABrqg+H7
 27.1301 ++8HDg6NLh5HcoADrp5he+WJ7scJ1AgSEvFq6/CRbmV6B1O6KIl+CRO17AIL/advm
 27.1302 +z82GBwZaEDLVOK1udMAPMHQL/SAIhakmhZrj2cvgUM8DqkraXD9smilAhM7ABA35
 27.1303 +lYXQzCuGVXM2bXGBEd3kHvEsTUQYgWpI21bjtUbCiIx4eIsJWoo9LgJh+9lrRZNZ
 27.1304 +I8lE7GciKqoV3CfdIbcEOlEvYd2uBBvOoB2KjsmqOS5XvwV77xzNiSxrtkf7WF2K
 27.1305 +q3t10Thtl/0grK5RgVj9GTaJKpTQGnS9pxytcj7XAsbq1JtZWJRVykntd/sjzdMA
 27.1306 +EQEAAQAH/RFXcfYFlNg9Jce6zlXVFkJGHk13SPB8YEPT44+Mvv7+LbQjprm0KU4a
 27.1307 +laSr9LkuqNaltn98iNaGGGf0ZSIia+lTzd5SLJ/33PKbY5Etik6+tlTZwFH/kQKX
 27.1308 +n9TkOoepyXyRGhi16kWwETdbjjaMKch8vwR4SDTGU7TOQ94/Ribpgi8WHV+pNrjZ
 27.1309 +rS0epw83AHuBMIbkRwncmJelCoaooq8O8VJlV0fZXzD5z6+6qJiEhBPFfRKhmKrP
 27.1310 +cC43D1NgirAkWKd7jAvrRlmeHvuXJ9LAiUdT8NqYfiovALrR86NI8O8b8+erym+P
 27.1311 +Cg7Tyg3Gkn910Pihc0d8fbV2dZTWeZkEAMsqxqMqsKRmwkGn4dz4um/vMlREQQ8W
 27.1312 +wQ15zm1tRWfNN8UUNPqKyVn1W0KtgpmcIIKVKsXMKm1qjuhdTFAos76Dhexjyoif
 27.1313 +myR5CaQMSbjPUW2fH0b0Gbq2MdKezwFuC1WWya+8dfIo//dkZsWaDGNFfOQ2CJxE
 27.1314 +VOSo0ODP1av7BADt9ODZRrRvvQQ4eqSt6+Tm34T4AytwddGYPwBgCJL2HI4JvNb8
 27.1315 +c6Ba6wHSgV1jnw6ZVDOXnjx88l6xXR6jJC8AjCJZOo0khXbBI9yOBDf0VmQ7YMU3
 27.1316 +RiKH1t/BKYVjD1baakLr2Us6qhkd2VWhqor9LC8y15jBjCBaP7bNdpSmCQP/UVSq
 27.1317 +Ly8+cx7TvsNSRNY5erCa4A30NjyxxJ+hEWo6aWM3Q6SjQhH35FVz/DmDcaIDJRjw
 27.1318 +7ZBOqwgSC03TYOocSi2qGoOSHMYx+sRVA/jz8G+FWrOUeSut1FQJpQ0oBvHPNZUf
 27.1319 +b7vVNHHiQ4i4/Wz4AgUMPBiYE2HMgEQuSXBEJEQ9ubQxcEVwIFRlc3QgUmVjaXBp
 27.1320 +ZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBAWx
 27.1321 +BI8Yj5OsTUNw3DMS//Xf//neBQJaXT+MAhsDBQkB4TOABQsJCAcCBhUICQoLAgQW
 27.1322 +AgMBAh4BAheAAAoJEDMS//Xf//neweMIALrA+cRNEtZcke/TQWgvIs8X5TUap5xp
 27.1323 +5msw5JoSV/xG7jB77RFRS4/GwXHTISclrEsCvMWPPStZ8/JuHQ5RoSI6i9EbpDIM
 27.1324 +BeE2jXpX/cI0vJ6cut7R6dRQ/wg34huaR+/eLQjdpoIiw63S6a/ERZs1RBbp14kQ
 27.1325 +LBuGM7zfjaa0TXSnZZSFgSIqCF4GqMyBbIm9TT5NTsda0IjrpZmCQ3FPVMYlFb9J
 27.1326 +PRvTWLH1zQPSiEliF+GAkTNc4jGQ11qU5bl7CTrLW/WaQkpOtOZciO+guKvz45XU
 27.1327 +dmTuS4Gw9OcHoiK2fIG/o9tl5G8XhugOlxKaeG3S0QKdJ1Gm2CNQ7ZOdA5gEWl0/
 27.1328 +iwEIAMivUQ9kPE0Al7/4qipBRRjnc1cytd+s6akEzlkjxn47NjnCixd3lS4wXsHi
 27.1329 +Kh+P2O1+7eVSXgKlC2VLz54C16jr+08xvjjjTBGcqv7HSKLBYuN1ZOJ9uQ8Tjoh1
 27.1330 +2w83eWOU8BopW9PTb16gkf9pc2RJAUXMyh7xdaSXEffXEUbKVLam4N6kZbIc6aLh
 27.1331 +OxoGRIbBIL2yvyHxFItgnRJrg22oJOoYkRWonGga2YT0BtlSRj3Q5+E7/XGveFUC
 27.1332 +vtGg3xEvU5Xy9xbMxkSDmN6o5GtFOB3JZp628OYWNMbGDaCmqFNWBIoQMw7PZGlD
 27.1333 +yujQ3QLAXbzsWPtkCUzSoBeYp7MAEQEAAQAH/A5bxM/2Gv5jaXgZwYsOanQysyTt
 27.1334 +AuhDBeDK8Dyee6gyclnFmpAORUUtvsnedacWcq3jZAABWaqUxnDz8KHckDOM1sk+
 27.1335 +xN5rHNkxvWZHOeIzNfESSCqQVjpG6u7Gh+rZzDycvmUQynooaZJ6qJd+ovvs4UNu
 27.1336 +OJPoMMOa73UtFRZcaRLJwS77v02vrxQYVn4Tlob7VPrU98qiWYxtOYm/MINduMld
 27.1337 +0xRTcfHA0xPG+E66JGPgIVx/fSo+sitEfSnqyoxdjln8vO8eFvwCczmds+WKjBSI
 27.1338 +Oc99P7Sc+fLjvCBVr7h+UbIQ0WLI4xfemPGtMj95FKQHJmSFlyxO/QypswkEANEK
 27.1339 +EAj29vLJCiMs3hpBtG4ATlAmd+DO+IOgHsfQN4riZUVboqhsfZZJ5n0kSfpL0m8m
 27.1340 +F24hQ3acGhjGJqWBh0ntqho7dk0r9+nBWde11YeGUNaPUNCfTyNu8Mcr1inay8Jw
 27.1341 +Jj96B80CDEW8CxujA+TGxuyIzcbd6IfvoF1o+HmPBAD1xMja0BiM39jqnZJNGYCz
 27.1342 +71W3oakeORW11oXqf3l1C/xFwU+A66MeutpJdF7rpeERrE5Yd3nGBClOMtRukcf9
 27.1343 +rmgV1iRG/1u1JLBEE6V5b0a7eLmlPte2puFe+xj/4s0VDGeAeB58PMqpJSF92TOr
 27.1344 +Kbivb9vU52D9B3jVWHy1nQP/fR7T11hOYgPAz10HuAklEISF6zDm9an8zqqmE22r
 27.1345 +9HPNc08p3iQ1MdI5AmDU7siVtDmnPxHlzWTNAmWAYUQfheSEC/H4HkBxlmuu7jWd
 27.1346 +wvq6N+LqoQLuR7KfxCjECuWEpRFJh+5rgd0f/MB2G8LanORVANZk5Vqa4BcR47qx
 27.1347 +T3FMJ4kBPAQYAQgAJhYhBAWxBI8Yj5OsTUNw3DMS//Xf//neBQJaXT+LAhsMBQkB
 27.1348 +4TOAAAoJEDMS//Xf//nePXIH/1K2dCX2ouVCK8ih8UcuSnT+PZ+lkIV1zCFFqsDL
 27.1349 +HW3cm0zWkvwTyDl1AIE+XrbcjFFyDn+swP75FSaF8jPmSIgajvjAhx9gP8bMyYr5
 27.1350 +joKhHLCSCWa8V8trkq0ykp0ULCItD7e1uLCeELoOpFLsjhPJ6gzbUT0Haxwh5/vV
 27.1351 +W8dKYSEKvQ3GoBxFVNtJmkPpDTjS5HBMeI6hJp4C7rlOjecxgOKjlQvy8GkXIfTW
 27.1352 +vaWFogBLZnVRUz7Id1BFYO706WJcpYMApr8JH/ZncApAPrixnN+Q0o91Hd+IujaZ
 27.1353 +RwETuvKisq/hP4/qpDcUrLNHwBoo/AMPH0B07pH+Gse5S4uVA5gEWl1AugEIALjg
 27.1354 +B8p7KNoH+qtHcYeywtNcz4qN5OwvY/l27UrCGwWZqLkj/zw0bqPnrHOwZwmJhEsU
 27.1355 +LkLvwsZScMLiJBi68V7cAYsa508DVGTl+jJp7+jCTnAkUF/fP5ldm/fbmipd0WUb
 27.1356 +giHOUvq3TAtko1XXRzRwZrFKo2jcdzHbvCtg4k3fXc7VhLtC8+JaaDKmdqRPHLOl
 27.1357 +Ivd4uYihMMX/NK9W6mj41nVZLrloxsSwtpMEy2NTjCMx0N67lezQe/DNN7hPkq7J
 27.1358 +NB8vfPlKiOGxsvxyVHDxJVsQukEedANOZSwF5g2+WwyzEWWpjBA1S1CGeuDq+xlA
 27.1359 +bwnjTw9fhZzW8INg9/EAEQEAAQAH/RAn6nZhjz8yfaTp1ZGIEn+EYlICNr8Edduk
 27.1360 +mXW0LcauWBt0elxpW+vbQJZMPveLOseRiBNrFB3fBsyjv4d2ZXEmj8SiFr8FvvfM
 27.1361 +Tdze+3YJ7kSINTU+SLa0gqnv2R1FB+9VLpOZY2YBOQDb4Ww3J8P840nbXcQO/s7u
 27.1362 +xsG8XI/KbwAfb4kd2F9jFNHyw9Jv3EecI3NMzqBnpuAy9uKBOwIrkJDTsvxBvm1p
 27.1363 +YJ6w34LberdQQtDQE6/D0YqNue9VHzuKaexm+60Se6E8ZB7i4o6hq2rasahnwuBR
 27.1364 +beTAjrLeYunfoGVqrb7MF0PWh67+qfNKYunC9u5uNP65UYqTcssEAMk4xNxcotj5
 27.1365 +Fs+tWTRoj0resayLZjnAwtRdXiJT2jWNOK+pGdnk81JUFszepVeh7C3NYQqQKB2D
 27.1366 +UqL/0bTUnzx49VMK/1IfPB2AugNiAiguxvnOY7YcEghCPogQcLgWjEGbn+JxQh25
 27.1367 +pJz6TtNcpBDRCHlJ4PgGnLv7jAtqlHDzBADrNA6w+M5NYZL47Z5aeUUHUsDUnwDD
 27.1368 +p42yM16m/6W7enO0jxJ0Su5s05qW5WxS75nSvcWnVaLJjkORevyjANC2BAxq+/cg
 27.1369 +riPBGiXpT/+wlRYqPqX5u5ljxZPs8/WEHJ68WAqkKWBxd9nfi9+Dkeje04QkBaQg
 27.1370 +sSyKufXA26LMiwP9F/2LnloZ1qjwxWUblCYnsi0//QscelMOQDOi7KXMBNEkVpkS
 27.1371 +yWkkSFCT4tn1MbHx3baeJ1m+dcpsYHZgMQXcSOziTBGI+H4HpUDCcSngmat8bjtS
 27.1372 +7GB9FFHg6qYFD08mtEhB5orydZJLCCavLMOItCRIZ1+R6VrT49wzI5TU+FtRS7Qx
 27.1373 +cEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3Jn
 27.1374 +PokBVAQTAQgAPhYhBATyFL+JlhoCwmg32sS0To4iS/F8BQJaXUC8AhsDBQkB4TOA
 27.1375 +BQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEMS0To4iS/F8uzsH/1Jy38gq9ucw
 27.1376 +IMoG/M9JwSzt/sbX0qz7cJV8/VDqY7og/9vJ0uvyeHSKEjqLLwT+dDdrUxzhMJQV
 27.1377 +2tT9NHgVdUBD7IxJ8cLZBRTesT5GqxV6/kL5OQjbaGfTTZWUSu8gwD4cG486UziW
 27.1378 +eVxYHISdUqlcFlM61y+7NsdNvPf7HMPXuq0LZxHhi4iTTPTobZLvuhMy/pv431wE
 27.1379 +umTxeWlV8frVSN+2SouuwjfltYsEW/INdliRtxrSPjt+IeX67kYkzh03EpmQaAGI
 27.1380 +rKWrcJInDBr4jjvTDmLpA0jmTof+ezYCedNU0lhu2da3Kww9TWDIllydWljGHrX0
 27.1381 +TlIjZBJbTJOdA5gEWl1AuwEIANnDWto7aCVtE5+Wj+YaBoS4FeRnZc1iwqBgxAG8
 27.1382 +HLY5QcPvJkMDVyxye/pqofBRMzUY5gmQO2i7CZEVgW4TkP8t5BGKLNqZcST1EcT8
 27.1383 +wfogxCyQKQ8m9+SJq+KX2RhD6SPwn/mkHFOjT/b65on1h5h0SRn5CdRElLhGKweh
 27.1384 +5/33S+ElJYECuyyGSYkFQLWJrASyLIcg5Pm7Vw9L6UCVAUlylUA64aBFGCAW/cop
 27.1385 +oeJ/pUi9vfp7gjBLE7EiGEloG4BWdSUQIw6qhY1E04QPbECrWEKPyl1SIwiwI90D
 27.1386 +Ii0cG88Awia8NNnRwaYNkhuAV72kw8m3bfJo+XpARJWhM7cAEQEAAQAH/2LjbOGH
 27.1387 +cr70LqIdHFGw5d7lPcPQFJHVVG7CIqBrDVrO24eflW9/F9ouTxCj1dAs/6UQHn6f
 27.1388 +SetAbJK/Aly7c+/9pgE1DzNh1NiklaIv6eKteIiIGq0v1AirYCvxKvvy8u+IOQ2D
 27.1389 +sf1lP034GDL0FdRskjnCNu13C1Y3PxkjNBfGm/RiIFT+M3T1JXo4uWB1G+2ej1vm
 27.1390 +ZTVqAgfYc2R2V4F8ok91pKBPSaGP6fOyv0bwk/E8XJ8nHfjMns35H2magiTPOAcZ
 27.1391 +Mne8S60hcU/sVZYfS2G5zogeLrQfmzfiujq6D9nRWMUqEOFXy+gPi8U6ELesax+a
 27.1392 +rbMBNNyVSSOIxekEAOuLWoB35f6Ubct5u3dM2fi2slJ4LB5jt+OUUW8GvQ0sToX2
 27.1393 +uwjiOvYlrXJ+yTvdIZQmc69iKR5FaDYDhp98oWs/T8NmjwzLwpMgcccKW6rqmtEu
 27.1394 +yU63HtFgkALGLMlZi89ltj6GHhj3/62mthycPfyXtGoKH2Z50IvpFywhQMQlBADs
 27.1395 +rK/X/fN4PgvTpSO35w+J/gYSNRlS+FKByVq9I/0P8TxaZdNjHvLqtDL+y4MxeZI8
 27.1396 +/OLCK/DNFah9DpOkD58zE7VbRFR/puVn59jitdCk/TeKli2MXQBG7XZiwpu7n51R
 27.1397 +FUiZeMQ/ypb7LqpJqfo62+suv10CWw60ae0ZlT7DqwP+MA9X6tMIbe4DK9Bk79PZ
 27.1398 +Ps3Nea6wetg0IRmVloiV7DFtiPPjnCIbtUI62qBYBSaH5K+F6CC6P13eulPba/8z
 27.1399 +0WhWZ+J+kMvSdaLMq0Y7RHDF0/XxV4NtcFM90YvKIRf/tbG7JGndVqHtIQo59fX1
 27.1400 +7Je2As9i4bpXdXIuNdsaJW9G/okBPAQYAQgAJhYhBATyFL+JlhoCwmg32sS0To4i
 27.1401 +S/F8BQJaXUC7AhsMBQkB4TOAAAoJEMS0To4iS/F8Aw8H+gNSR6fp8L6luScLE9dQ
 27.1402 +qRCJ2TAamVYmAsg5QSoqYgIxSoEm6ocWikmUlZbUnpc6Ab0lhSzFjxID1cNISMHx
 27.1403 +83WQ5s6xsPXcRGzcaCOEqwCS92mhYLcNdXgw/mh13wtMzXgIdGIVrHLmCH5FQ5SG
 27.1404 +JYfJl+dHtQBDMbZRWt0eu7wu+G3uICsT37OwhgaDSWHt2D8eaQfDIHFjCIZwUg6Q
 27.1405 +X/f2JOF8Lkiz2LgIpm3jDLRfNkmJweuKSJxNsYRLzdrGlUhTArHEle0WpjRDCuVi
 27.1406 +/k0zeXEzHm4E1VxuWF9O/YjNdEWPWbl6uQ0HsxQjM92oNQqvjBtdNIZlvuY1gN88
 27.1407 +1x+VA5gEWl1CWAEIAMihMRaJQz+/1DCPhcuHjCw8UhseHo6EkvNnNe+Rx6B6o3o8
 27.1408 +mBC283vwNk7mhpivaiL0oZ1N0T6gb2qdFSszPbeLNl/fD/uVEMxsnEeSsZBEHQns
 27.1409 +Y3KuXyldNzw+SoVn9FX4GKgIPO/68JAUQjWKelrZTjw/EbhuMPqoTIQTGAq7psB0
 27.1410 +BKw4l3vEa1hH30H/IuwDK07k8/JCKyxu2KKGdm71G1fdnKF+zJiOPqIuI0xC9vQo
 27.1411 +ep3Wmk7L3NCD+6Qh9qz4PlES6pPrY/3RDKwW00Hdoi5B3y2cXhto81umEIK36El/
 27.1412 +5mOKPPj7qtXX2JYrMAXZqKS9dDy/1oPMAXhoYs8AEQEAAQAH/ReVWGeAGRHsTa1W
 27.1413 +TEbsFwkNdM/6jrhNUyzIwWlOJztw+bh2WPWrW8cCKeVvvvtBsLs31auKUyyxFTJg
 27.1414 +u/VJClnXQ7v/RNSw5WRHkWiZu2+W4hxMLOB1KNB8REWQ7kJCQaa9XsCZv01Xn7bV
 27.1415 +UCG/tmQ+zlh8nWui4Epb8Cqc8qLdeHio78mMR8cSJ+kHEYLccCBbxd9lH3qBwujM
 27.1416 +95J7p1JDJnawkrh6M0A532DU3xB60qcwEk7j5KRRK3Gv8dtD72+szyPqbkSxnwIS
 27.1417 +sysO4N8oZVcywk0uuSqQucq/cD/kn3nXevCYavxXv/DYwDfThNsA9OwcPIJtl49E
 27.1418 +tDpabFkEAMzVVSTGkFg10HIAKSRgMiosC4ZNjz8La4fm/QFFVL8aqqWYi1BZBNve
 27.1419 +hjrEr0yLVxs/FJdUZPYP+0KNNVflcXhCPObG25ruKiEPY/zH2ae4Wtz4kdS0Qnuu
 27.1420 +ZIQSetIOLs6WsFaEFSk8xjxrV6mLip6KfvjE1p06Xp1esn15DgUrBAD6vwr3KjAv
 27.1421 +H1dExbdi1V+99cWGTiozUxBHlFx2HYnUMtsfkA4HLBPdLDhB5SFaR/E8uu97xhj2
 27.1422 +uodem2lfWUDetgC2TS9ijT7I2eB55Sr5EboBeIuDvFJaA63KMJ1b64dWhI4G2/ef
 27.1423 +QfX+wFixMu8agkLt6h7YvMTIkwH7kk/O7QQAnLByiQIN+gd9W/dZv2w7WKGscavl
 27.1424 +QLn0Rn7dHfQa5vVwg+dZ/+/ETTzOj2l9FBoxp6yHo4qVIDufmDqLBEY6uXzWOM0k
 27.1425 +0s7XNDgvfLwzKIwXJ2ve8SRzZPYUw/30W/XaOdaCbVf4e3PXxTAGdIEQdgkYSdWK
 27.1426 +MqbCUmnynOaH4BxB77QxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNp
 27.1427 +cEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBMIxpo4zV6IAFofXbLS83+ngSbCZ
 27.1428 +BQJaXUJbAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJELS83+ng
 27.1429 +SbCZD7MH/1PNPhfcomPoc60Hgoy3hD+ssJh+CYWzgH8V9Bu+bR4d6x5xtiLZ7pYC
 27.1430 +HJbDTG+aNxOLWR31cwJHs0ZQ8a48rqZn93pCSOsDk4QBAMaWFQxtcIlbPHVlA/s4
 27.1431 +TEvHTVEa7D+8Q7ovNr0UZwFsUl1CCis586MKiZigc2RT0OhfF4MhQpYsMjpXVy+Y
 27.1432 +EdwXGiTxtjM5RTEM2I3F2/sJJ5LevRvvTxQuclWRX6EOoPDsR2CrrfH/2tGbUixl
 27.1433 +WR0tjYilqQbXVgDjIwUlmZpf6tvzcdx3NIkDQ3IfMiUnft0k3ctF9AwjpFZMhywC
 27.1434 +qipWJhdtbewFCX3olsG0kpX169dVF3edA5gEWl1CWgEIANKRDayBYTrbaNhxtvp5
 27.1435 +WLXSDnDdec2qYQ8MbimEP2xyWeqLoSUvajV0CqFqi69X9Lss85dxUJY2J1P+Q0/D
 27.1436 +6OJI1ak4CD2o8ZjBpA3tvHTZhOV6LrkhjC1cyflmzlvRY8zScQbocxasy5pRx2fZ
 27.1437 +4Sz9LWU2pIzw0k4c9TwrMJH/4HUVqPxsb9r37SNAwZLaLW1WLidl7bUfn147m9x5
 27.1438 +BzS+18AggSlqFPS19YO1+nYj9gqdOuLqHgXobyGpVdXEixbaB8pHoQ/SFdL90Pe7
 27.1439 +V9Sg7gKjwPcEjerxz1A3Qib8cVf2OIncnn7oRQacHDfsabYYPgw9NKxgc/R+/jsY
 27.1440 +ZW0AEQEAAQAH/1tsnZpDxpqOf1RS81aHb2vqW1jH4MXaby/gfshJ4lvMvpumqn4B
 27.1441 +u0SgMKlrIGEueFT4rH8ZtRqzQpomcMVmU2xEoXhKmtFi1Bs2IGvnyAaYFyqnxTee
 27.1442 +iEV93zgJWhnlrUZWLLsKHEZBGlnTnhfKMwmcl6Q1eHa1bSp7SkMooXsR64BGTyVE
 27.1443 +yvC0gzlT/4rzxdV5AhaDESd1aJ3XEDsMJ4ZxH6WHAeCfW69MAqmP0wq1bKtZgTxp
 27.1444 +hJvF5MGEoilfLlvdWyS4B29H8awXPbDYtvD8dumxlD78DjJhYCMiYpk6+p0K4LcW
 27.1445 +BV68EK0u/jjNLco4jAyIbsheADaKZg6xvsUEAOBb79p85ECaMU2xsiotIsR4GRYr
 27.1446 +Hu11YDjOXvO5k0lx44EDqvxS4dhcUms/fRT/IncfLE1PY3SOJhDS+BLcraaXGm6n
 27.1447 +8CfrzEaqJTgtC3JqQ7rczY7BaQiMa+9lNeeQB+ohtCgrfPFA5XhymKkAL8KXyhax
 27.1448 +cuSTCVKW5vOjqyiDBADwQynurI1EDIBOOSDAl+7XIP2nN3S759hf65FapabEumvM
 27.1449 +IwGQ+AZN3OtM0rmY3xodwf3vuis824TKXNKbKs+WY7xCpgiEYj19bv5rt7o8N8yW
 27.1450 +n1mlmsEW4uUJZaJTFLbd0EkVYU8cGe4vIBgvCKv6Byv9sL10LWnyNY/wYiZ3TwP/
 27.1451 +fysnsZrx+3d5MTHmKEQvSft38pd4r4e3E3KjXKSevb8Cy/NhGuaX9HMGHn54EG8P
 27.1452 +CelvrNvpUgDAdqlG5gEInMI/0AvHOgmhA1yQcC8deETLa4SYUJzYlPeWnrLZOPi8
 27.1453 +/3NpX2RDqC+LVbaelgV2gkzn7AFJizaC4DJEoc81W7c3wIkBPAQYAQgAJhYhBMIx
 27.1454 +po4zV6IAFofXbLS83+ngSbCZBQJaXUJaAhsMBQkB4TOAAAoJELS83+ngSbCZxzoI
 27.1455 +AL/YfkKbnNcOTtJF61VVmrc5XbSbNiTkgrpO835yTM4UOo/NnqAtFtMcsZwb9Qxq
 27.1456 +0TfEyvpzpPFjePIyL1m6PLIGECshsI8bBHpbCobufVVwuanX0fDcCdJmaSGhZR/Q
 27.1457 +QUgFMXUvuwOj42WmELpuhO8sfStyI9izLCZpm3O4gavffxaANMDgQ6acVULNriCR
 27.1458 +5dreTpRY2cQb0/S3hr/wQOGlEvVokGUwjr8Sm25qxJMXXFeewjINZwATYuRWuzos
 27.1459 +ESAeA6HN0bUOYZ0y6kSxp0rPWX93Xmdn+7kEmz0qjehY/4gNHdsFo1V7P5zF/Lfs
 27.1460 +vwls1nK1PniRBlstosP/W6mVA5gEWl1DbgEIAPHlp58Y1N+IDWiwC/ujgm4z/Ebu
 27.1461 +gWScOydEM4fC8cloaXUFPqGW8wqaSKNCRTdaIxNdnlZ+EMUi9bGIXJMxsYLT5itG
 27.1462 +9LdKXn3brUoP+/PrU1552PiSIOepj/afuBVHw1hQWOv63g2zBuyt6Q4apxU3OrQQ
 27.1463 +8zKHPybZHrgqHWt4S+1+8vRlyardsZvOTYGHNGuz6j98xPpWsHyH9qaJFJjqZ+uC
 27.1464 +FscuBD3sEiC7yZELuiCXL8kZNtpe7RX4lbcpbZ2gr0jQopdfTpfF8BBX86RztQVT
 27.1465 +flDDJhK7qEKzL29jeGQu7d7hF6Ph4BMjrm0Aap9jOnUKBBnamGq8idaZXXsAEQEA
 27.1466 +AQAH+wZPTMOIJMld5aek6/MY7UaNoZeCEir7LknUbBmu+pqb2CBezibt5pIQuzNS
 27.1467 +/7Y1ajPPndk4uZxC0LDcUzndsnksqNTZKXn8fSGAUPFdIF/Y9BhDSmcVfLk+QYyX
 27.1468 +1vfrIsvTcLZbGV63HEehM7KT/Ga/xY674HQhdgK/6B66roDGmgxsRqEkLP92aBdJ
 27.1469 +u1yCpGGXLtyzN9KyAs4H8Qxrc1ecTUDP27Zd0qLOOB+k/23C0BIdhRM7Ggf8a6tU
 27.1470 +bF43L8SqE1CqM8qGIDEwLqYUQlToFivsGM6j1TFFXYXsjmBZVLb7QGgZqaPK9kDX
 27.1471 +zh3aeE8BS2d1QM0uGocHzva7aJEEAPSHAf3IKc066X66lQPRkCfNUxkFBs370Qxm
 27.1472 +VGj+tPUlqdOaUfK76jjYI/xqc9a4yZhqVJaDdwYk0TMectEDmEdM3hyo0b3XqivW
 27.1473 +zy5zKuNF5AMx1nhnq3etm1Ms5fNEtj4f7uRFpwJ7asBEX0xrFhmIvtzi1MVXDPiw
 27.1474 +iKPIHQ/xBAD9Pw4PF5kJJT4Epv88n2q/nJJRNVt0kuAqaE2ZIeBJ0hkj6WTGV0Il
 27.1475 +moQIjeelwkiYoBVYZGGIhnbKjUKTQz7J8PFMWwhVoKWHfUuKPd+Bjn52JhxmKknM
 27.1476 +VGuc/1O93Zk565o0X+/FH2Pf0XQycAtjNkyMx6VLkx8h6oWp7OKwKwP/THaAXOi/
 27.1477 +KlJHWKYsT/xnqmDQOFDGs0vBQ8FYJo4xRT5doI4PXIWxkxmFBzR6WvkxsioLKDnG
 27.1478 +K7GhrEbXK6wYVoaGbKNIruMheTbLtDvkDDhrqf+Ik14W/zBRjDCDBKqVNuCSzXdX
 27.1479 +Rhn0rnTCqhbUQsydvsijQt+YC8vSJHZD7bU8YbQxcEVwIFRlc3QgUmVjaXBpZW50
 27.1480 +IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBBYKd4s4
 27.1481 +c7J+r/gMSPd53JBfLTgNBQJaXUNxAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMB
 27.1482 +Ah4BAheAAAoJEPd53JBfLTgNg8wIAMSaxPOuReeDIUX7seAv8LPGdsh720OkTT2g
 27.1483 +UR/ibIRtRApcsA1JMW0RJFBB0NgdJJPkpiNHogNXMhbvwHVtYJwRdGj3KW1lqFhq
 27.1484 +8x4Wl0kmIHt71bsJBLup9sz14KL62pMYHQJsPzfcke61WtLn2F8jQ5hkNAiJO+bG
 27.1485 +hlsipLEFHjPYqZD6F+Jpcesv0/J9NKCjdsXrVbbpO11X7NuOKinVBB4PWwJYx4+j
 27.1486 +mQgqFjAzh5eEjHexWg+5GmUEznBv2ATNtG0sJyt3bP+7cWFLGj+C6NiCWB8kFYGP
 27.1487 +0vj3emLowaJ490I9eRLp/CoUGW5bV5TxToUVQTRnkeEuRlUMH8CdA5gEWl1DcAEI
 27.1488 +ANrM3mtiOfcPM+/0HDCUnzRIyjVkdKzHmszdKzazqZuhNy9rq78EbmOUy8Pgrc9H
 27.1489 +ay6/PNdqHrQW0ZsJxSGyOgVbKc2SDeNHRQCTAEwYGQpotN8NbNBJo206NsQQMW2Z
 27.1490 +knTyAQUi/0AImEZduw9CPRlrNDvlE6zTSyHBlFIEcISYNBLFx5zf/3ufxLqtQ45Q
 27.1491 +SfGBOzLtA7cWJrDkJfK2Gd/Ofvq7yCRRxgb4RWZP5zYDvrNZrvqJJR2Q8T0Pcrjw
 27.1492 +ApBI8b4RJrTDG8iIvbuQizZWNNabx/6ux19qR9KsDyt8TRBUiXyUL7BQQvUo47ch
 27.1493 +CWAFpAnGp7evuRgXeS86sXkAEQEAAQAH/RDwH/4f+XJHiO2tZVrvv8pdodppHNd8
 27.1494 ++p4bjLCcTx08k/0rCz2LQ4YYev9pKYi8vo6ndczhoB+wuN2/xMpowHFGidF/mhfL
 27.1495 +M4uJlbyOTK6fr/Qo1yYMXqcs75fqfqpoI4HDnpzDRToeYDa++KVEALRddkqhCiP3
 27.1496 +Kx9hcRC6BhbcMoMJyccl2vSVraLcKWW1tGI32tRgA7+PlkrVcTuAfp7dZbnF0+kn
 27.1497 +SD/g4kPW+uEHOtUVLkQcYId1BMr/d0U0vyyd8grug7vEp1kic4FOw2z4v1V4oJ97
 27.1498 +0hqUV6+k0hPCxFgZ/sz1DsgN9of7szFtnO9As/EXVNEtvSgwpL816V0EAOROeyxb
 27.1499 ++Oy4MbKZJMMso7MpejCWukM/YSj/y4/0PJDc8hpAowWf3cLIjtFDsnzs6CJtOPNB
 27.1500 +cy5SEmnczfU9+z+K3+BdMflhRNmd9kV8yYDQgLBZmJA5apCPr29euMObGZ1ANQjC
 27.1501 +sGgql9pzJjeQMCbmBF4/JiAWg4eNnI3TxZ59BAD1VzEwRVcr3qzirS43mczyA+ok
 27.1502 +jjh0tTduUgpQtUbOFYrgXkzvBfSB56L3L+2N4CoNkGYWqj1JH4GYHW5DZby4bFYz
 27.1503 +Y8unVrpwC1b1ckdKqZM3N00TqVcW/Unpv5v27WkV6CIDj3+oEFgoSv+U1E+1XD1i
 27.1504 +g1xgduOokJ3mK+mjrQQA8pONtQQCO8Q8SPd2A7vcLsxR4PXoV9cARo6mu7Js9qCL
 27.1505 +bb/PPQn+0sYkSZZSadRsF8XZD1cvD4pfwmzCYWT68Fsgp9rGEKk96b56kTQs4JF0
 27.1506 +WfRGDbKbFQtG1Bx/RxZdzTHyL00Q+CATYSz0HAiUP8Q3cDZfk5/8QwPO5IBWnyFC
 27.1507 +/IkBPAQYAQgAJhYhBBYKd4s4c7J+r/gMSPd53JBfLTgNBQJaXUNwAhsMBQkB4TOA
 27.1508 +AAoJEPd53JBfLTgNgBsH/2K8kMoKNALxaA7wAtbaFnvNfNMIoMpHi5HUZJusISGx
 27.1509 +4wGhZ9I58xJ+G+rZG2GMP84mWnsP6Xfp7e93zpxOQ3HkYugguWGIuGDalaG0bqRZ
 27.1510 ++L/rB3za1CWPGYqGk2FD2LMOt1HeQO1AX+PTkygu97NwMxVMmZMHj3ukaoIc76dS
 27.1511 +albO2LqAk24KfMVgslUdm7xpcOtjJwow1yCABJmxr0Sjs8Ss8IYDHJjG5TA9+U9Y
 27.1512 +Nda4zBx98oJOOFTaf7Gs6/rLc28MO0GlPIjauQSNFEXPgax6u0s2taGD1hRNqobI
 27.1513 +AASv/+jbXLvKu8sD9HRp884KROo1VOsk0s7Mx9JupyQ=
 27.1514 +=PR6k
 27.1515  -----END PGP PRIVATE KEY BLOCK-----
    28.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    28.2 +++ b/test/test_keys/priv/pep.test.alexander-0x26B54E4E_priv.asc	Thu Jan 18 00:46:19 2018 +0100
    28.3 @@ -0,0 +1,58 @@
    28.4 +-----BEGIN PGP PRIVATE KEY BLOCK-----
    28.5 +
    28.6 +lQOYBFpfqMMBCACz5nJSa4CRwT9IaF9HVduwwhv7Ibwu/5xEviQDczmeUYxGS3K5
    28.7 +P22aKWKiGdu9zebCBPqozLTz7bk4yCbIxuUm4+TVyJx0ORgaPswmbp5WnKhnzGo8
    28.8 +7iKLHerXTQOsFyA0eyVkEokR4GmNlyc0KK3hO4M6q71A43bYf7J0uZdXfezMoYJG
    28.9 +lcJ8UxmOLfB6GrNjd2zD244Csa/tCqjNXp2EUI4DrJWByVN18pHAeT+MmrJYkMM4
   28.10 +lOeQjeFCkPnekn8afBJ3QTaEF7yi8qrWQ0VJQpT9MSe56f5KaCbYWhv27ZzDVGWm
   28.11 +OavXDWfNgCp45jPEypAcD3jcUUrmTonYELrZABEBAAEAB/0ZeUg244IRIYwUdLMJ
   28.12 +Jt806EeOB/jdrtQx57qxwl8mS+XRDl3wXUrnyXRt/7td5QoH7yyPOm1lHQRdRfo3
   28.13 +8/H+z8ZXf1CoJG2FSd8ekgtZuFUgXZGtjwrVKCdY1U7vz1aAF+/ze6xtG5nWstCa
   28.14 +UihM/GBYrnjd91ec0Hg0jxMfEDiX5S1GkP0VVeCp5/gNgNxymgMGa0WWQArxaa5G
   28.15 +iwiVf9LIjiHUm0yOpa+5KvOiymu+zVHUuM0YnGcTM+8WaUVjXRxZ/9MMHKVz0Vmm
   28.16 +xC6Kqun95goFivIrzpsRgSBCPR9q/cx3tS+kCgFsCiF75DYIxU+MzfjTKlu13HoI
   28.17 +gjQBBADA08iS67xjjKAk3/4Akh/zz8Ok2naZGLloiMvhRJK65pCNVJAzKjvYAQsW
   28.18 +9OGTgpOTqUI/Ep4Z+ol+s3UV+/Ih1Qb/3XcPR/I2xPsrva7z9Edkg+fTeiVywYqs
   28.19 +r8ffjpDKh24sHAvMDc/UCYOhzYTGZuTxsJK4ieGyZpE5Zx3+zQQA7tZ7OEzF2Xce
   28.20 +7Z/TMYVOVf3lgGV4C9Lc4WSPHnrbW4oY7sw3dpHk1982+Q+2NyLMdPDSeJ2517Li
   28.21 +2U0KK/xv7bH3upHzSHNT0xh7iegWYM/dfQfZ4g3BPhths4jlm6ccVYqKp0qTME3U
   28.22 +YNcWpMBo4KZpXJiTjDU3klBJPAAPFD0D/1nBRlYjPPbTE2WgTjipqkl26xBLw+XV
   28.23 +I9Dci16Ze7Tfcpd3tmxNmGKgG9GElytr+rdCbAF+/NfT2rD8hNbc9j2vxNo9YbF5
   28.24 +FGL5deoXXkQvdZJP5d3PJ1XDWY3OfjO/244XzqLFhfywYdY9qS+berCvVdeQioou
   28.25 +3WyWgskv9Z8BT9O0QVBlcCBUZXN0IEFsZXhhbmRlciAocEVwIFRlc3QgS2VwKSA8
   28.26 +cGVwLnRlc3QuYWxleGFuZGVyQHBlcHRlc3QuY2g+iQFOBBMBCAA4FiEEOtn2D66y
   28.27 +JnXbhzoTYtaYEya1Tk4FAlpfqMMCGwMFCwkIBwIGFQgJCgsCBBYCAwECHgECF4AA
   28.28 +CgkQYtaYEya1Tk6IEQgAi8lkb117YPo+yOQGHryu37bgHn+pfEVHctvV3iuacEwz
   28.29 +kpXSyOKS5o6/0V2kuLiWTBXLIIjyQZ173LdOiDv26RlaOfwWegaw/A3QxedO0j3h
   28.30 +1MaSV/6KEm+Y3Ti8B7bvWR3Uct/5D4kkC6MTNyhcvtnnQykzkg1HaSSh7mL7rUQI
   28.31 +0RNWLQAEtsWvUNpdfZCaRwpp1Ivm830Bmg5PUTC7lJHnrg9Tcd/YVVAShk/1Y3Hn
   28.32 +s20paq3cM1So5J6SmXdrm9sp/9lnBhK+/55N3JgsRcjy6Q0ONoyVfJOV+UjugP0V
   28.33 +WmEEncrjYRKqQ7pvCyx3gFDv8vRWtHndYR00V2gys50DmARaX6jDAQgAzzSE1q5Y
   28.34 +5bcSXP2qGSg4oeVPK5Uj2nb4DF3IDF6KGmWiNBk/DWmh0v89LjvgPR5l7HcHaQr7
   28.35 +Xz48FFe3e3kNbwSckTLip6fnGZhBCQ480hMjZjXICetpc6WRbj8UNsLGkKluN4ws
   28.36 +uvtgZ5z+XDUrOwgKgwmK2KxBWh26yhCZqUYt4+l6wYbfCvzXIlUReaL+kc1lEmp5
   28.37 +nQKdzLOXKay2MO5kY4ZTQLh8vsGIS03AoG7HD4QuY6AVaB9tZ08wwoBKRRxh2/+Z
   28.38 +a12GX1qVm4aWdQd91cyaNepHnLOyejb9nyenfBWEFx171MxOQRocasZSoE0+DQ9H
   28.39 +tlI6GeSov9CbhwARAQABAAf9GvLGKhOfzTSLp1t4YXA5OVkU/GKXuKSLazRRPcaX
   28.40 +6In6WBNGf4yS9tmqT9aKufg3olLyvEco3UC/WJf17ZGXXS543GuFTe/I3yvNnYtj
   28.41 +/qBtlK/+9cdPvjI04WVD0EFxyMO4aXIKKUFjTuZ8sGpb1oAbueImVDrG/xzpu7j/
   28.42 ++yNAzTIFvdHsbuHlK5CZ52j7hWqkR7Pgji3qit6+DBMRXnwMqHQFVg685uKnwumt
   28.43 +Bld7fdxc9IQmchdAfIlF2xDQ/sadME3aCe/aJIXxka07OSJfguIoLkdYCQ8Re4gG
   28.44 +Ge6NNe5QuGpJ9d+b8Wlw/O3zZB9PnALfqudtQxLoznJ+jQQA0aNcEESsAdaTFbXO
   28.45 +1xSUv6vXXQsFS18CSKMlcM7Kx8KYwC2PkzwQns7YS98pHwWW0XiYBt+YPiNpHKfv
   28.46 +kvcYk0iavsOEoxjVb3dtyzH+BAgtKcznwnZRBLK+/dTj6RHPJ3+3OyjKFDL8QRtF
   28.47 +xMBUv8oQnAUXISiCb3vWX+PY+uUEAP0HarZ+uiYW7J1iMwSlwOx00Ne1Nz/9rtts
   28.48 +Z1zUCei85HtVZ5yHqhsRo2LZhBkghwVkd/xrcbLzBvDmAVdLDAwd3x7yH/ogzCzw
   28.49 +qZXgyrno5JSpWUj3QIebIH6vhWY3sooXzdviJYAqXOtQKq4QcWntcpFxPbxEpQCP
   28.50 +PlvM5Vn7A/4voesQWnZM68SDK4q9YCdcBmEzH8YXNfshD6svVzfhEKD9CWXCNn52
   28.51 +lyYOD839Ns7T0A0CL3/4STGNJ/RMu+N9KYKnTrVgdBXcMR1U6sgXlLZuWWKze8Zu
   28.52 +YNM38dD3rlhsPNXvHQwFwyv07SOtdsgpRy5izWdSZElhm+MDXLUu9ESBiQE2BBgB
   28.53 +CAAgFiEEOtn2D66yJnXbhzoTYtaYEya1Tk4FAlpfqMMCGwwACgkQYtaYEya1Tk5R
   28.54 +gggAo2kakClMpSC24XoBbkCCLd5UgMyb7AvqUOZgtdP+kyS1AuRHuur2OhpF87By
   28.55 +EeZs+ZxD8Hr0sju372hNey4c9e/VFMZvru+315RCF+4I/Cv5iMq6YhBCoNlL39ij
   28.56 +zto3kCZlRXg/twBPmB07D/M4k2/FXZWjqiQaN8DjXlIzXK+cVggdq7PXiyxurFdL
   28.57 +ghCeBKc+J8ZR6sshYPkpe7SmgGqqeRX2Dv+xU8i4mxXM4JAif9dOWpxoWqH49ReJ
   28.58 +Om1gWCHou7d7NS5qO6M413dqF8QWO1c71qt5OSpq+wen9Z45TOwJo8wxs0BgtRZV
   28.59 +iNqClyzhbFlp9Jpk5HhTOxOe6A==
   28.60 +=sNFr
   28.61 +-----END PGP PRIVATE KEY BLOCK-----
    29.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    29.2 +++ b/test/test_keys/priv/pep.test.bella-0xAF516AAE_priv.asc	Thu Jan 18 00:46:19 2018 +0100
    29.3 @@ -0,0 +1,58 @@
    29.4 +-----BEGIN PGP PRIVATE KEY BLOCK-----
    29.5 +
    29.6 +lQOYBFpfuwkBCADXNMGMEroRCUpZ3jRQ9o38NBbOlmXXQ7ZSSuXdbJU9xd+UOUsj
    29.7 +JLapYg56XbU7o17oAFfa9VZlX57OtHbdGuoUgiNS5QT/T4R6cSiPg92+riVygVop
    29.8 +ncERHsXq+7noyiSdv7peSfVygcn2Z6T63HkY/tGJJVPbfFDDUWn+qKDydpFkSiUx
    29.9 +2SDBhgDOstYMxOsDRlIEOWWYIBXKJe2tN9DSA7nDtnu1GapLNHtZRfib8E+wwK5e
   29.10 ++WijHElB/dvJdL5Zp/gT1jhtr8WxWdmbKaJQwX49VT0uU/IdWfwxfZKEjaPTKNU9
   29.11 +urrRDq+0Kgo/j9s+edYiN5cKBUkIoEFNE4LvABEBAAEAB/sHCecwrSYfy4V+hfmB
   29.12 +EmdXcd6zGBExprnOXDvDb7s7335uCyeteRRuWtItZ2Y3kqLWhLha5X5TZ3q6uQVQ
   29.13 +OwKf9BeyrOHqdc/X716LvxzgETMRWTC5PrsjU7XWdzA/8GidLjmqvtGD0sHnyMEJ
   29.14 +IW/mhOMWkL165sh/cui8FwjYlT/IA3nKO1glAAwCBQYc16ejMqWn4ghyRjmkpv8F
   29.15 +GULn3dMI4ewet4MFvqTZN2OjU7KiBTEka083Ht2yChLS16dSunfwP5M+i9wPklOz
   29.16 +GXfLAsxqP/V24tysLWyoOC6VTIJuqLzc4o9A5zdX9wukG3gEf7ceFRp6U8KGPtRu
   29.17 +UXExBADXaOQQPZ+rAn8PJTDaWFRtrFm/J9V30BuZCsN56EZ7A4nhZZkguC79vC2N
   29.18 +EoI8PzbPTSCf7Fnm3Y166ExxC1drftMtsXmKKEk3lGFUeCieiHFhFyc47nioGT2b
   29.19 +mf1kxRUUjKGq/1rCLi1lEU6z1FHpYnKu+uSEoVPTQkC/EvUdHwQA/8IKj8OKVFL6
   29.20 +pENUtACp/3ofSh+6DxDZj8+63sScTMY1LytNTn2lu9/7NyVa898ppuEq/qtrD4ti
   29.21 +o3xqT/DBhXKnFp1rQI8ySpVPjYF0KLBqdQth8YRuPeOdNAbjoOGtQsKJXzJSVu5s
   29.22 +dW4zdwFaeUxD3p+f6x/fKPrwp+PJEDEEALYhX9p0LV1GLpmGGvZIO7mBwl06I6EY
   29.23 +O4Ett+1fN0AdeAEtszomyTotCa8TDEmpVIvISebsi11eNXn/0e44jjFM9Bemdeev
   29.24 +F/tBcxbaKgESWIORf0Tgpf1xmmACG0O/yg0geQQD9v2cAhQlH5jgCBmVB2MJqwjb
   29.25 +5a6bHoBdDUIPLGi0OVBlcCBUZXN0IEJlbGxhIChQZXAgVGVzdCBLZXkpIDxwZXAu
   29.26 +dGVzdC5iZWxsYUBwZXB0ZXN0LmNoPokBTgQTAQgAOBYhBFYxvxNXMmoCqkcO7rgV
   29.27 +73+kUWquBQJaX7sJAhsDBQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJELgV73+k
   29.28 +UWquzNEH/1CB1zM18gXosslKF/Kxh0xFqnXKvrc7W4pO/rYNW+qfArGp7p+fjiqc
   29.29 +5amPWO7GINW5BPw4taoAirr6sXSYB9uWYxRXL//euTcuAIyeA0Xvw9I9EL92HtAM
   29.30 +e71PNcsPeQskTtfCUGH2B8OZ84+bTSgf6WcLT9CSESHl84rA+mVXQneGTXbY7cJ8
   29.31 +i6g8HedNbzz/wmAJoByYrei1lypPnWXawBbxheDe45NmvL1AQS7psXTPHJTFFZWC
   29.32 +bswfEtYobRFX9UJ9rNGp0tY0CmzW4qRwR38P57XkgurgM7nOvlYDlVium+qv7ERw
   29.33 +Q4wsn5cSuAun93vjY9TM9O4MIzzFKdOdA5gEWl+7CQEIAOg2gQ1AF4l+/2GRwwzB
   29.34 +Rk845rzLbpp81Hlys7JQ0P/klE1zoXcSWnsBAHV9Y0utIEGwIIxKB0TAi8CFlDsM
   29.35 +/pAI7TPjIMtxndltA0JWsWtT9d0HtmyOCslk4VvFCsN7UgCrklwPSnabzbNr9W/J
   29.36 +0bpGK6sey+u0BEPAcbZPRndm8JLy+EkbbOaah97xKt1kvtcutvkPwof62bVB0i5+
   29.37 +GuvX33b5jokBjk9eWdSeZSNZQjiOtArCdnLMa5H/EbdG4Ge4b7ey//E4VKdjGcD8
   29.38 +KfW4lA6N9XZbLfJNjjLWn0XUa7BVE8K+6RDWZ0cmg4v2TC73YarNW7N+lTgwf86R
   29.39 +HMUAEQEAAQAH/AznxI3SN0yornRDd9HcZvYtrSMmci/rSpqyTXrWQ3tJPpW8XKej
   29.40 +sTwfTuF4tb1FsqJ78Z8iWRuQ0OOC+P08KGSkXlxxHcg4uQNVq+Xyr/sNSD9/t3t6
   29.41 +fG57aQvi3EmHb8QCRQjRP7vuRkUXtaUAFCQUVMZ2mHIxx7/lMNynNL0bdBtXUAsr
   29.42 +RTqBiOLq1uS1yOwdOjzae7Y5IDGZ5iwmTNtO+zVRtlyiOQ2l2lXLc8h/1n21W3io
   29.43 +f/MVKePNXDteSIJZ0UJIMRd5N4Ba8TCu/yu6iKANKbtjbrMhP/1JS1z5xCRxyfVW
   29.44 +n9DMaAG/wRiCrytRZ+bjdy4oa7d6QkoErQkEAOwFckqUHKDLtzP5SXjrA8ZTLuPW
   29.45 +4OaxmyRMScxq7KoHw9KXyvJ22aueeHRykLSjg3RNka/1L5mE/ESsZG5qhXhgJtIC
   29.46 +JGHpKg+vUmfztBdFRA38vLVdY1or7fio07Bqg9V06Nfa6eVCK004pDW5YThqOkbZ
   29.47 +tRTfhy97FDVHKI0NBAD73offmAzqGQrED0ilcy7va6/0cYnJderdFpY8MntRZSKd
   29.48 +rOpZWFAleNVzQ1F1HGOkhB4XLvdz3OI8KS8q+KgupiWPkx7NAZXV8mTA8JHUwFNS
   29.49 +4K9Dv7FpbW4Agx77+zK097B0ICki/BNDF8k3VHgbTnoSRhz2o+stKlrGP5QQmQQA
   29.50 +y6WSbOxPFrZlUgCJxDydcVGgDNEb7cFSzra56ZQ21By7LKOaKcdiWe5xI9iLdAYp
   29.51 +GRLsmmEzxn4KiRuYSkGWJlVR9o/2ZFqr6ZpGYY+WyJpqDckmfFmPFMcB8h9r4lIa
   29.52 +WDi82b8LP1Iosg5jWVYjJ1swFgwAfCjyG753jaRCzF01sYkBNgQYAQgAIBYhBFYx
   29.53 +vxNXMmoCqkcO7rgV73+kUWquBQJaX7sJAhsMAAoJELgV73+kUWqughYIAIpK+sEe
   29.54 +eRt5ZKCEH7d02F4CXVOCRY/+hJXwVVBtE86j6xjUgUpC0tb45UmUfiBMfiIN/aU5
   29.55 +6tE+8tsl419oWyUXhR/jX3hBHxxWQRrL7omqKM1pC/TYt2EH93g7el4Gmv1xUjSG
   29.56 +/djdaF15iLyNsBVMH7r5VtvAcOhhiEZQzAUXek0HT+oD+g1rt91CIG/IN9SBpd0c
   29.57 +7JgIe5m+W1rVYl4wD5JCLi371eRokrVr6pd4/tSF6KBoik9HOphNbGdx7O3P0Sap
   29.58 +mjXUGbq2UmjsEF9ObP32NdCI6srekivexxn3FUUWEe/PK3uGh9vc8vHONWo268Ld
   29.59 +Pnr7619NE1SUzJU=
   29.60 +=GFL3
   29.61 +-----END PGP PRIVATE KEY BLOCK-----
    30.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    30.2 +++ b/test/test_keys/pub/bernd.das.brot-0xCAFAA422_pub.asc	Thu Jan 18 00:46:19 2018 +0100
    30.3 @@ -0,0 +1,32 @@
    30.4 +-----BEGIN PGP PUBLIC KEY BLOCK-----
    30.5 +
    30.6 +mQENBFpctn4BCACx7hSdsA+AnAQ+VRT8vb820MUhgiZ2gBOmmjZt+R+U8jGA0RFT
    30.7 +OFGWMNwVNNDV+FFES4yTbbmH3JPEPfRTKzcBJrty0WfTrCQ65lv1GBmGPO306pg3
    30.8 +/AA8n8e7SAVwc3fHB0oImQTkiN9Jx13KvFhSm32e4DWlDEYEIOSXY5ZjmczMoLTq
    30.9 +mwbf0ROXI+aXh793AS+oUlxl8CZJxwW8EmLiHAc2KJVXubJCq3nkwtz03/NvgCYL
   30.10 +M0cXds/jNrEEpTbXjx7pnVJC1tIrCrFrKChM4qUpcWqSPwn0pIs8EP2FHS5Ou0MK
   30.11 +O59bGVWP5EPy2gyS8bfgtWt8tL0jilBlUa4hABEBAAG0ckJlcm5kIGRhcyBCcm90
   30.12 +IGRlciBVbHRpbWF0aXZlIFRlc3RrYW5kaWRhdCAoSW50ZW50aW9uYWxseSBFeHBp
   30.13 +cmVkIEtleSBmb3IgVGVzdGluZyEpIDxiZXJuZC5kYXMuYnJvdEBkYXJ0aG1hbWEu
   30.14 +b3JnPokBVAQTAQgAPhYhBPjOD34k6xkKL8v9ONSwiKfK+qQiBQJaXLZ+AhsDBQkA
   30.15 +AVGABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJENSwiKfK+qQi+OMIAIXUeU2A
   30.16 +74JwnbtO7XzGZ60j7roCAOAn5AHxGNnWlguRIk0it+7H1PPdFMETWDKATVesmNFV
   30.17 +ATQ1vs5/G3TmHCzie/yjLMKHg2ivouQhEde5x5sbI+w501GDinDLihJC1kIrBW9M
   30.18 +nEE4LniXZ1SBXoTwy9H7vLhvgckHp3JL/zT3Z7hn/oGT21Der/smYJp8lI3gLOA5
   30.19 +2eFCiwtzn1Rv09fjUYIcuvHFMl9o1yJTu/hLSRBwJliLdvl/HQLiM+onr7NoJCxd
   30.20 +nvDrQUqMVH4qjDAHJKZMjjy5TLkoTAcLeohO3NlMSXmRIhDUIr6S34hUNdrHIopO
   30.21 +RgajXbfKbM4iAL65AQ0EWly2fgEIAKnO1DQBmoB4KlrcNKXlCazCWp0cLPWB11cI
   30.22 +Gpb0DGeVEndCxQfBGRocZs7zZn1MpEpzRx9Ae/R/o3w42IaBF62RXOpofq2WSe/T
   30.23 +YI4QJJvSPJ168VuP9BmNeARL0Q1EAMro483LCCUpGIOb7uC9hn/Bi1OmK956tJqE
   30.24 +OSYqrpxkY3kw3CUVknDCd12nc7zB+1KQDCYSqQVZJ5zkagr65E26SXfvzf3n/x+U
   30.25 +B9FhnIE2zzkUJvsgY7s7z/XL/NXDuKjPbbIL6bhhP08koljCN49q0pSlB+Evw5ou
   30.26 +kmON46JSe1YymBzVA49b73IrSVrXKT0tbKVguiUG3ewc9aunUpcAEQEAAYkBPAQY
   30.27 +AQgAJhYhBPjOD34k6xkKL8v9ONSwiKfK+qQiBQJaXLZ+AhsMBQkAAVGAAAoJENSw
   30.28 +iKfK+qQifC4H/13K4LnWFOqSAXzzqnass2aY++1EVXRnMDdXsp3jU17tCFJZufoN
   30.29 +Aw7vmInrCgxMViUjfV6DfyDsrYynDWfIAS6FO3ThnFtgkgekdTrNg6DZOMl7D9+x
   30.30 +aP0S/fVITZz5XRqs7amRkojftQHJMpPNoXwcGK1hGLgPIvN4cbLIRvnGSDhkstFd
   30.31 +svNbC92z2upit7+yq9eW+Kn2exJRszgbZ53ghmhNy4CrhjJC90CsYF1SzsDlqwc1
   30.32 +ET4vjV1pCnjyVk+pNsw1V9kKMm8icFFwB57xX5Q9EdwMipNaWWg7CHMM8+Bjqsj2
   30.33 +qHs0LNWO7eQyr8Uj0BwfT04Wwz68iD57lEQ=
   30.34 +=Y6m7
   30.35 +-----END PGP PUBLIC KEY BLOCK-----
    31.1 --- a/test/test_keys/pub/pep-test-recip-0x08DB0AEE_pub.asc	Wed Jan 17 11:16:22 2018 +0100
    31.2 +++ b/test/test_keys/pub/pep-test-recip-0x08DB0AEE_pub.asc	Thu Jan 18 00:46:19 2018 +0100
    31.3 @@ -7,25 +7,733 @@
    31.4  8+q/vMDEtkThR+JIn2IeX0U8c/Trq5ek6M88ST63sU1c1Lbw1TENhch7UJl85MxQ
    31.5  zyZ/FRWlj4zoPfEwdVolLaS+hlGMH5tsNk1/ABEBAAG0Z3BFcCBUZXN0IFJlY2lw
    31.6  aWVudCAoS2V5cGFpciBmb3IgS3Jpc3RhIHRlc3RzIC0gbm90IHNlY3JldCBpbiBh
    31.7 -bnl3YXkhISEhKSA8cGVwLnRlc3QucmVjaXBAa2dyb3Rob2ZmLm9yZz6JAT8EEwEI
    31.8 -ACkFAlh711YCGwMFCQHhM4AHCwkIBwMCAQYVCAIJCgsEFgIDAQIeAQIXgAAKCRCE
    31.9 -2SF5CNsK7p1nCACNWH+sADtb9OKOoiZX3JXbO66D7YaCsuIJfh1ZtViessDl6uuC
   31.10 -KULkyZOhRGkMMwrlMetfSz4/N6HxiPPNKfdDnJnP0gX45KOsVKB34VdgvYN4kUKL
   31.11 -4hvAAxfJC5nI+JXuOwUbxs6FRYkQrYYv1I+qufdaCzAWc9KLeyBpp7uYNBHOOELr
   31.12 -WxvAFMDPMBSioCwGYU04cJsBLXQCbsxdyFiZSgAS1A/oIEQ87fZtPYuq6SHrZB2/
   31.13 -bsDiEIFKDmK91zY6phZtgzVi77pCK6YL/GZBi5ZSBXuzVFMjeVwJr3ajsVDs78FC
   31.14 -mKT+lcmAvZleEhMKpovs1Ng7H1v3EQU2jhOpuQENBFh711YBCADZlca5RzMLUOX4
   31.15 -2+krKFcK9KGjanackuKlU0DbDh/F8x3ouVDV3+Nu4Ti6/fxtnuaSW7ZmssOTYGJK
   31.16 -aGqRjpNwe6HjY1giMr5KO2J8TsOJaKhPyrgCzgeX+a4nAIE8P8CeEiYOEG10wyZ1
   31.17 -i3PH+JdeAmDR2/YoRAB5XXaKAR+z1Aa1i+tgdw+nyZSN9hFvOjruyoMdvkcEo94x
   31.18 -3Ylw4fVkzTl5zlyss3CgRzJa9EW0BnpH2OVTi6S39o/YzUidWzysu2I2/DhUcGuW
   31.19 -DoDOXD1ILULhUIC4UF12t0coBtRPIG4MoKya5UkiVK0j6q2PD0yj5EJkvyn77NSA
   31.20 -HM4Fih3NABEBAAGJASUEGAEIAA8FAlh711YCGwwFCQHhM4AACgkQhNkheQjbCu6L
   31.21 -Mgf/Vbtpj0Y3swMYWDahLZjjPKPzvaBnLHnmlZJS0culFItLbWTZB7WuHn/pv1pX
   31.22 -sKF4XNnl/zK8HPEEJiVuA2eWGsA9XgqBGYCwYs8zhJFkeQ55iGGuMhGyPT3ie153
   31.23 -vqjbDXGC7ajlksEwP3ESrkLjIuHWov8karzIXKiz4M9qnrJY6OmNfO79qxigEs5B
   31.24 -uIZNWS/Dy1de5RAfQgSVvD3uXX5cLUAO/FxKfHVoHdL7JEcrJGf91T+uc9LDOtcc
   31.25 -vZRAZt/l3M7qRNudRF3HnvunsfNMi1xLzz340lVKO564mYT38yAX9zhkfkPQwHlD
   31.26 -zt8ruC4IUKQljSKCwngrpl+qyQ==
   31.27 -=2MI3
   31.28 +bnl3YXkhISEhKSA8cGVwLnRlc3QucmVjaXBAa2dyb3Rob2ZmLm9yZz6JAVAEEwEI
   31.29 +ADoCGwMHCwkIBwMCAQYVCAIJCgsEFgIDAQIeAQIXgBYhBJPRnyStb0xLqRNKr4TZ
   31.30 +IXkI2wruBQJaXUQHAAoJEITZIXkI2wru1+UH/RIteVXEUBqyJ1S68hn5yGNiR/3O
   31.31 +X012TuqU4HB1mt4w+mKCUVwEInxXivpWqQbkWRNoI6vkf7cXHEPiFOdjuek4DPo7
   31.32 +D7KOXcXWvttMz+S+HPXZk5PerDGxz8bruvfbbi63YGqgRrBIcdfX8jIe5GmEd3VV
   31.33 +xjZKEDr0/czwWn40W3RAEm2EZfg/RnxxHaW3TBURwJlkRGA0IrpP5OibI8jxpx5O
   31.34 +grFeZbbFw0IkNANiO57XNNmH1CL/ggYZwvC4h8WX/b0w3D1r020jgo+M/VS3DfeS
   31.35 +n/fMzV5n/a6A06poARmPFOsQN3qy/4hf0EbA52aEJq1ucqbXtlpsuDeVX5y5AQ0E
   31.36 +WHvXVgEIANmVxrlHMwtQ5fjb6SsoVwr0oaNqdpyS4qVTQNsOH8XzHei5UNXf427h
   31.37 +OLr9/G2e5pJbtmayw5NgYkpoapGOk3B7oeNjWCIyvko7YnxOw4loqE/KuALOB5f5
   31.38 +ricAgTw/wJ4SJg4QbXTDJnWLc8f4l14CYNHb9ihEAHlddooBH7PUBrWL62B3D6fJ
   31.39 +lI32EW86Ou7Kgx2+RwSj3jHdiXDh9WTNOXnOXKyzcKBHMlr0RbQGekfY5VOLpLf2
   31.40 +j9jNSJ1bPKy7Yjb8OFRwa5YOgM5cPUgtQuFQgLhQXXa3RygG1E8gbgygrJrlSSJU
   31.41 +rSPqrY8PTKPkQmS/Kfvs1IAczgWKHc0AEQEAAYkBNgQYAQgAIAIbDBYhBJPRnySt
   31.42 +b0xLqRNKr4TZIXkI2wruBQJaXUQTAAoJEITZIXkI2wru7mcH/iE6LKxNSgd92tsV
   31.43 +XyAz4hAJMgWd4yrRlNyUCeeKFJVEvQAdu8ysazd6atlGNdf0hLAJs7LnzE5NQBwL
   31.44 +dfJixMMm2vb6+EKN+hGYYJJL2GW24CVGCkc895yykdPDtaV0PIRS878P5mSEhuZN
   31.45 +lw9SDZotb3ipQRfX04jozScsYPxxXYtJrz72ghE2NosU3M/pEHMzTBfb+KJ9wUmQ
   31.46 +ciL+c7RVpvCTGb9QomdZpuLZEOAqLdbUZ10YggXvLI2xse+JitlG6uB6Ieq3dGLN
   31.47 +ITOgc1pKmo4WI3rsY/FuHhuYfT7g68svEiwzmTwzeKAJmFvQ5LWWWTHx5IemibOQ
   31.48 +9C5dgXeZAQ0EWl0mOwEIAMntRnGKBZZFyvx0WmbrUoHpAktcH/RN+AAxEOixLZB+
   31.49 +zrWW3owCzEoM+2dhxPXMfJCn/N/DI3r6P0DPWbXfUhtcqW70YMEUAoVVsYKAc1nA
   31.50 +BMid+v7uxtL7xmuKwUzYhGBl2NQ+/cgvFN8dB8lhy9DOnYT9p5ZUy+DhdHb8261/
   31.51 +MWOr/sW0oy+xzFncvnDkBKKQUkzW6zn9vXTtCPKtgq70IOzwmfohAHcHUZpLOU71
   31.52 +cQeRmaOIC6tfHGprUMWFE6oFLrdKwOcy66IwiH/s7zOEWfCtlV8YYaA14BzmfNbE
   31.53 ++w4Eb0WAsvYwnFlMPNSL6En33Xuj9oT/fqNTzd/o+6kAEQEAAbQxcEVwIFRlc3Qg
   31.54 +UmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgA
   31.55 +PhYhBEQtvu2faUNx9r+0F0BCeJwpy2+1BQJaXSY9AhsDBQkB4TOABQsJCAcCBhUI
   31.56 +CQoLAgQWAgMBAh4BAheAAAoJEEBCeJwpy2+1/5UH/2nufLMaHMjRF9is4m1B7wvd
   31.57 +JAooemvwmVIXBgjumEVLA/oYT1whKThiZEi8FTMaQB3zKpnCOV8hve/xnFH/zNI+
   31.58 +RgIYZrtrVQT8jxkKGfC6u3gUBiq6A1QEhB3+HJ5/Vnxr9ZMzKNyqq16nUkX48eek
   31.59 +yLMl739Wyy8l/bnqJlUZV1YiKgptEs0K8iqRNpjWmYL0Va/l/X8CCzf13eMu1cY+
   31.60 +JeDcEDrglmM8vqiHGs/Y/6aJJySk71YB2drr279AuH+JYUCmO6EntJX/5bZktOzH
   31.61 +8FN3KS+GTnHupMzDTIsQspepadZfylKJkXTvxJ5lqNbM7RSmt4VgPIubWkLoNEC5
   31.62 +AQ0EWl0mPQEIAN2cbAy09RNMf7o4Slpmc4SVoT/b0ywdvF8u+EISDJTM9Azg13j7
   31.63 +q0dl20+JgIOfyKKqoea6MwDtBtVRbAMWQjxtrs0S1eWM04u+9vPbxragoIFKPFpT
   31.64 +WvtqVCQCzOPbja9ECRHVSpXNAj8tEz+344LSzTRDpwh2KL5FKClyRgO7bFAIum9Z
   31.65 +1EZVuVXL3oYhJ5emLyBbVVhVonW6Rxltx/KiCk0qGn36AdnQXdrdtrcrVuFJSLht
   31.66 +7+VuWwK2/2a18jBbNsjx4p3oMGX4V3G36wfBf1gPAv4e8jhN6d2jDN/O/HsPoDaV
   31.67 +rBwHHf/0mM7bJR37RUgxwTITba8ahqLU9nUAEQEAAYkBPAQYAQgAJhYhBEQtvu2f
   31.68 +aUNx9r+0F0BCeJwpy2+1BQJaXSY9AhsMBQkB4TOAAAoJEEBCeJwpy2+15TkH/jVI
   31.69 +Gni6Y5fBr7oqMlMDBfnAfSeXNIZhBGutPcvYStzRhUFsB/goRIlXaLsNcdg+AU9U
   31.70 +lkMpvi9vggqIAYNQf98RnKOTLzl6o1yb0tmxbzOT0C9qsN/5KpNC0eiQdAr7f7N7
   31.71 +Zf6sGD2Bk3h+fsARZVG2pKCZLTaPkoh+bd7dPVLfr8vmLHfnu+4fc/Il1FrKxD0n
   31.72 +VSks5KzpR+ttfrwoJrZOwpADtMM7Xmfj5jT2XHRcZRo/n8x+eGnVQicYlNzjh1RT
   31.73 +u7wlaqdf+G1t38COsTCz2SGqyVYmTMlozr1B0vv2IirAmkn3NYueChgKzi/AevtB
   31.74 +fqzsoRhU9Xem9mS1mM2ZAQ0EWl0m0gEIAMpw7llUVEl0+18QJnfbzuxvVoyVM2Jv
   31.75 +vUjQ8f5GgmHqScKYZi8Of1PHN+jlf3F4lOcKomYPBHqipcOtYNkj7h52Clu3vrBk
   31.76 +1g8Ku1kD8TQL+k6RM1hc96+34rmt+HkAvYgEnXRpST0wkF2IPrs1yL65Ep4xICMG
   31.77 +55EZfbdgrn9WyN2iSAaxdUeG5jFzLMm11VTrnz+RQ2k4IwsEMxUXKrxQ7yAVqBaD
   31.78 +xDF7iyAQQy3DUXD0jVaz+wCriGNjQV8mFYa2DUgyr9vUM/FcwjIGqYqJxWJsXVL8
   31.79 +A00tMV5ESs3o7WEhvbDu/KLfFOCsuDmAa7k7IdmmVy54511aGbceNj0AEQEAAbQx
   31.80 +cEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3Jn
   31.81 +PokBVAQTAQgAPhYhBMFOlnkDKecxT/WC1fAxdmAvZZ9dBQJaXSbUAhsDBQkB4TOA
   31.82 +BQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEPAxdmAvZZ9d6F0IAIpVRoHbfaZ2
   31.83 +goawft6Mg6dPrwznM90bDI9gq0UC5Dt+nShUhgTJ4wSz/iG1XHD565ML9HHkMsQr
   31.84 +ZazstNM4lJqqAwdIOMAQVd3/sCFX/8bEPO8UFQDPB0XcdNemNqfbC1n7kQWAFz9G
   31.85 +V3Dc3LJt0cDT094G1Ta1gyuVbuJ1ZfI3McQZvohebobIWkx0krdvHw2AfLBzItuv
   31.86 +pzBOSR/ZHGe0xK7FcmFxfPQHNfNSyOSBsfC+MILvwkJYTuSRCY+Lk86e9pp1K2q8
   31.87 +xGGVu/tdVRSFGiw2fuhEpL2b/daxaZ89qR9y+r3H2ycwJBTbpXIrvsbLJB0nBWEX
   31.88 +UFiHJbunbEu5AQ0EWl0m0wEIAKyzpLNBSEf6YWKIgKbF8FIbk5UI5e+wF5slB9hz
   31.89 +nmTqMWsmVDYaFOZBWq4IkKnOP1wB4DiaLnjmwSE49Fw4tyR5B16frhRX7cYJ8o9y
   31.90 +FI+6WA66YQlfQuhf3Okfov0JA683OkU690MaDmYbmU5+V0LD2tHcXPo8iTp6opUA
   31.91 +2m8XnZhwUZxx2s3X0Gru9nKcvrr8Os7cNtM+THyUuUK4yNGzKM5GojuoGhikM6UL
   31.92 +Pw4cfVuHRMMnAMZMx5sooJZ5yBx5r/FBV+os1TKldLpNXVr3bIMVpU8jU3ca4t2q
   31.93 +OyUGBY8WsKZko0n7MGoea3bzY3l72BDHrqHAduBiO/tOPbkAEQEAAYkBPAQYAQgA
   31.94 +JhYhBMFOlnkDKecxT/WC1fAxdmAvZZ9dBQJaXSbTAhsMBQkB4TOAAAoJEPAxdmAv
   31.95 +ZZ9de4cH/28GI9U6CzlXSs6e9zkZYtjqWwGZSN0wKp/pK0W0dtx2x1suxXo/CIS0
   31.96 +O0nPq4ylIt5PxC5rAMTeiGXjf3+3ujONem1GEsBwS7A7PThFQz7tKMlf5TfLp5Ln
   31.97 +mXVehuowspGnFkESYlVSDKWxIeGB70mJ13CUslsGYwBI1dXzArLfFW5hC8oMt1vP
   31.98 +AO39TsOJQm5Gig2xKNOQrczv0TCdM/Ql+nuTgykumOWnEwhJ2G8Q6B7afHYUcylV
   31.99 +xGDrZ8GP+owHvs+Ys88r6Aj0VGOHlMtNjlrlTOJ5prBUoObzPVkJ3uFUdKvsKDBA
  31.100 +8fHpuN9mAT3Vmf8FDZvFV177zuTdY2WZAQ0EWl0m8QEIAM9eLiG5hC0uyMRgcdf8
  31.101 +OsP4bktXV8hAN99SQ1m4B66470TDuLnSl+zVNrLH+9IfsvUm68J/KWj65e4jn5wR
  31.102 +IitInB4SCv0w/2BjB/xONQmhDxxCyhiUxM59VRSszcXO/5Qj3XKLhuWQq8V4KYGp
  31.103 +WsA4uMM2HvoQ0hv8s/sqk6JvsiXGo30Qoyg2Y2JRcy+X9nHN5tazbd29+G0GI8IF
  31.104 +UvtA7BsBe1iKOGe14BuPdlV2ZRT3T5WPO6oXDOvMOQPfhUzN8P1xhLDH3ovmKq0S
  31.105 +VigDU9oZRZcqqdaIq8o+3vSfZVHOK7wr6sdeTUedrvWysy8MsC4GqwgzS3WIM+KM
  31.106 +8HcAEQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3Jv
  31.107 +dGhvZmYub3JnPokBVAQTAQgAPhYhBGxW20NhmLO3qpPVNiGpbY7FarzyBQJaXSb0
  31.108 +AhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJECGpbY7Farzy7usI
  31.109 +AL1m6lm5FnX5Ja7yDED7EeR0IMTw3GZnRjSLHkDR+SQSOYdXvcHPpk7W57PP+Rvh
  31.110 +9tbe/4C8eaNuBchBdtyLm2CBXIB+91FlHkUDzap54Yr+nSUCQdI6vcJvqx1ryE3L
  31.111 +ye4xHs+mX+AQc2T5FI2jIUoI38fEhPjZVy/Z0w0EzoBweI6g4Wj+58Wy+lsYtuDF
  31.112 +MCvFKb7jdG4hGSr1I7e5hZo6o2Kev/wxiOwIG8c/OX9z1Tby+0GoG5wpCWp9MhG8
  31.113 +NklgMiDtKsfLfwAn5XdPmJaEYp47KyARGI2iiA8VS28tkRGMMVvzFJ7PlTzVU9b0
  31.114 +jpl2WKY9oDellg4ZgG6p4i65AQ0EWl0m8wEIAPirNF+Arvjpu27XnwMwxi20Mwwx
  31.115 +PoLWgxBFXph/HfsZL/z+GpNZBRkTNoWuFOIOxZc8OgzbHgbZAsuSM7eiH+mtgYm2
  31.116 +DpHZcRyltWOSu9o1tPQGMqp/0Pu+F2Lwceuq186s7DLBs5V5a23Azjk0wpNWYjXy
  31.117 +i2rnvT8bcp5/Yfn37+LdDmIrRE5+l/9+3FvLB2tv1ZQCEaz38GkI+rAB3RJdRtrj
  31.118 +9Qn0nYi77r0qmQIruZbCq2cXXRntftaU30OcrTvdY5REdw93wPeOuE75h/pQScnr
  31.119 +3s9ynVQXmzSszAP6TY/T6o+pvuoiZhVzZpU/1SKhFKdjT1UJvzGP4buhtWEAEQEA
  31.120 +AYkBPAQYAQgAJhYhBGxW20NhmLO3qpPVNiGpbY7FarzyBQJaXSbzAhsMBQkB4TOA
  31.121 +AAoJECGpbY7FarzyIJsH/Aja9gn/4WQThqFblBcU7KsnYk+5oSUWjhJFTb8Choii
  31.122 +PrYgunFhpAQUwZ3URHhCXlqg4EIOhGSxLNrSxx0mOMmAxZumir8gCTZY5ktcTJmn
  31.123 +rah6ZNOQkInJ7S/DGDKkH9wir/bpaS4bzKsixN8yneQp+9T6+oEtPqTiTm25S3LB
  31.124 +6JcPaLoeU95H/fqeAXfk1AsHT8ymlcoue8Auq97tFdQKu2SWbHcIHevPjwY3EI7+
  31.125 +SR0rL5bZQR7aonuACueAob3mVXGtJ77xpdNw7zVwwXnBN/af941DLi8c3Tr23cut
  31.126 +yyCOVMLgjUhcAV+LKzJIfVd8Hw+8IPYNOSmIbmGb1q2ZAQ0EWl0xtQEIAK9/miPA
  31.127 +eUsAhHqOJHd5oXMMKNy4cvkoIOnCFdYeN4wFe6rW+A0eOhH4DaXfEjAcVVwmTXAp
  31.128 +69s9vug6C55vloDo9FCIIA1dWZ8qaAkyZ3Rvby6yrUA6jXiTXbqzNH0XkLHyXnHU
  31.129 +qy2xOpimNMhnqtEhxuENcpBTsjlT+CJDJVtyKZ+fJ9Ug/52GUvK/+a1xcH3O6kNG
  31.130 +FZg9VvUKmHMoFKdivmFkPhmiFzg0rOT4FmIiQfNBBaHavjp9eHUz+R9S2MUU1iAM
  31.131 +FcBNQttxrsm8bgtwgL6T5Rgu7Q+SnOtc3CzUUBbmSsmVQnSqQrNvCeOTXIt00tBS
  31.132 +Zx+1XvbUyBzP3JkAEQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5y
  31.133 +ZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBCobrRZlujMFWKzJpPfPsNj+
  31.134 +NmecBQJaXTG3AhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEPfP
  31.135 +sNj+NmecinEH/0+wUlJx7pc0oTXkLmioD4lLlE82TkwSVvHT6MxGMtYxjKY/s0Mi
  31.136 +CX79pNyXrCCbA24mA67t1XPQpoEPRVknEEAlfCSS55Qa9k//KuMugFC3HvaRxy7b
  31.137 +8I6MUzLeTJXiF7jGdkhcoinrEt77tTncJIK7WBHNRgP7QUcA5I52vU1LbmzFD5Pu
  31.138 +UoaQU/BWDfxf5sLTdpIIyDXm+n8sGnyvIgadbbFTmOLwU9EmuMrg9F38grAjRczL
  31.139 +5QUsoMATeEAfpsQFQZglUqe41uyyLy9uugj62w5QjYgaJdURLXH1FYyhM/zfJUyE
  31.140 +YxuMxLTlG+gShARRGD5eMnuuAstdlEqp1lu5AQ0EWl0xtwEIANQPXF56qCUb8dqx
  31.141 +vDXf2p/kcWQLJCkRP/6xyNIRty8Db2FEZ3ADG+QpZU5yC3yJ3ixoJkoFa3mo+UK2
  31.142 +dLq6nx1FC816JnSnsKlu7psomaaqNpnEUZiX+46oSh3B+hOAS0m2W6FURb4bhE6T
  31.143 +D4XTWnABa24z2WGiugRpx0GZjUDd0CEbShC/fX3d1+Bj/OPfXR7Z/YD+rglrnfaa
  31.144 +uUMB+u1yinMOxnwob4Q+5gxUGS7+hZ4+is5SYGPCsN3KKxUdlNip9F2lyErtZeBm
  31.145 +hNKACZ83RQvJ53ayY9Fs70Q7srY/R/MVoi3B+aTG1RD9AKBaldFwj8dhcxESgNYZ
  31.146 +aFZmKBUAEQEAAYkBPAQYAQgAJhYhBCobrRZlujMFWKzJpPfPsNj+NmecBQJaXTG3
  31.147 +AhsMBQkB4TOAAAoJEPfPsNj+Nmec5l0H/j4EZBHzz/cI6fPzZqYegoPZ6rdHOu0X
  31.148 +GXo0HfuNX4p3qv8QCQi6GVQQpi09W9sAiF2M2Ual9qC3kuo8nq7Kbuse6NBIxDeW
  31.149 +2F5jamyk+Ffs+GI3qrwMzD1aZI4S9wiPv3Wq7d0zr/4Fe4AFSA8kQY57y5BTN6QL
  31.150 +XPN1srIxfX/2rAleIOp1Op3rH+0bmt/6xhGsGVGcCGpuQQaW5w8FEUQ8TKi8iGHT
  31.151 +E/l4oT8taZVHvJPmUSwZGL+Syf1z1D2e3kK8eKjlji/xmCQ8Q3OG/9/yRFThKzf8
  31.152 +S1vGRit4eVXEK/xXXJIgvVypMKStK1jEEkjA9HNdFj3/yovCtNrg+ACZAQ0EWl0x
  31.153 +yQEIAMOBGlyKbQxEoIGta+JaTdMYXXrt+HVJo2qatQCJbXqIJQauUZdP1BuUflMb
  31.154 +kkAdRPC4XS9JMzGSc/nznYL0I1rjI4xwRWSJyatD196RF1E9NUw5i6ptX5JRwJp9
  31.155 +PFZaVIxQghAMT86cJjbkYYG9/5sg7I4xBrxJfyewbFum0u1BAVgSa1I1faFcE/Z2
  31.156 +gMESaHP03h/SHhqGigambJkC0KY3q/wjCNF0QHCCb1e9CRzfiJLdqOprmVhS58M8
  31.157 +JNjJ2EXvVusc9d0v/7oVVWDyV6COK6sMSdhMGXz3uPTuA61tR0ufQaxYiGtpI4kr
  31.158 +ugSbTKmnr/AZiVXADgZ70zHcjtsAEQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxw
  31.159 +ZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBNR2FlbOV/s6
  31.160 +/YTeywTsh7QHSqG5BQJaXTHLAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4B
  31.161 +AheAAAoJEATsh7QHSqG5UMQH/RgusteCnkvO6tv2ksz1Uc3Im5aRpoTdF/vx5R2M
  31.162 +Rvf6pbPx4HG7clWiJrAw53xC3Jw0+LeuqKs7/hPitwgTmGtdicVTirw7GIXv51gn
  31.163 +zPud+43ETT/e1ZR8xCc+ZlnlzfYrRCFkOkwdu4SxFAWww8QOE3fxbkrL9OFErAB2
  31.164 +Y2Tvcwzu2nFfQblWURaKC0IRrd4FgU4MCRzcCfHY0MHLNG98bpnTyPkMpJ2s5dod
  31.165 +pP8+l1rlNN4LsXEc77fd15tdRWIVTILbZy4DnsIKpb6yzrJxHnZKLQZJvGSJdOR2
  31.166 +dTQN8XdB1kfRSJ2S3MqE5taMISf8jziGgYS3R5OBBeKIzCO5AQ0EWl0xywEIALUE
  31.167 +NfsslNFdAAK/1d+nnAM2nox9ZNczDyj3kjy3i1wHdsrKQxEh4zY+DpuGwjil9Y52
  31.168 +JdzQBZTA5Jp13BUEwCpTmBUBEbkR24MLCo4U7o2bzS/bPbmJuCDvB8rU+mLPGzaq
  31.169 +afaW/Wgvv3qNV22j5WzRAGTJ4tmYWKXC4kIK9ovF489D0965Eg3e5BWr9t+t7v3X
  31.170 +YaULYlbadj0ZxxHOgyqYheHPCGxrN6r5y7sbAwz2aeEV2GcngBRTNYiSKMoLYc+P
  31.171 +t86OmRtDJhp+hXxJLdslEMW92QJPVgLBLszBHIHjO879UkKfvcc9hlai5niLqIIm
  31.172 +xDIg1fBoNmJznsWzvbMAEQEAAYkBPAQYAQgAJhYhBNR2FlbOV/s6/YTeywTsh7QH
  31.173 +SqG5BQJaXTHLAhsMBQkB4TOAAAoJEATsh7QHSqG51zAH/0I5IqtOPdSm7TTK2pcB
  31.174 +kVPJXuaNR+HXMsH3qWZzG+M5obqSeHwiH7+k1ygrxDpIwjnWkcLYE8E2vK1iP7xt
  31.175 +j/d5+VdcQ17bIFIpQLtmW249tUoiAVe049MNnRSts4ysTNIZqjaHreiTRUk/1G8a
  31.176 +mBbxnS743sD9bXznnWs0znK6DbZ2yon2k5igDIGdsC6TYSn6vx3v3H9aGKMX/O45
  31.177 +8s1St3NDyVNfKY1MGEMHw21PLPUNQgs1GmCIMKwG+LoolpBKKDglhffZAOFl7UPN
  31.178 +3PBjYGwgqBXHqW6Og6Rro1Rr9QdERbki3TzE0UBXCISaRRR4msyesxFqsukQSVAe
  31.179 +4H+ZAQ0EWl0zNQEIANBWOIhVaTRhZ199H1O4uJTDCMGJzLywJTh0IhnS5HguQe/b
  31.180 +o75eCZO6z7mTQTrG9NN7A+fETcK8F5eRgY7fJ0Oze8cKIMLfNorzWKKRhkOpIMmb
  31.181 +IYx7I+gobgcmvxy2OdMFcHfDb74x2nxW6XJNhl3ZfjPk8Hd2qPHV3VJwwuFAmXo+
  31.182 +zjbvAbVXbLE7UxCnz1Qv5XBYReOKkpQq6Q8vFnQ4lln6fAvotijvCVHirMJO2VkP
  31.183 +MdU+1dy57+aG/M71GPjn3SOHSviq5PHxF3p+N3uLe4H0Eho9RnAnfv1OrXTw8oTR
  31.184 +gWxUXl+n5/ofUxPF4xTV3rLGFhCW/d0w0nD5WwsAEQEAAbQxcEVwIFRlc3QgUmVj
  31.185 +aXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYh
  31.186 +BM7YCWrhIhaAwoSH/fd6hr7BO/PYBQJaXTM3AhsDBQkB4TOABQsJCAcCBhUICQoL
  31.187 +AgQWAgMBAh4BAheAAAoJEPd6hr7BO/PYXn4IAIIMMeSejxp0LSfLcUSbCDLqWf4k
  31.188 +v2650pikN2YSWe8ZoCrR5tlO0cWapalJWpTA9gnEpxcgtHGUNO4tFYoeaChVPs8s
  31.189 +FxlO4lbDNfE0elUnDpo9Ct9aKQRhO1f713igWRN1KKrVNh5AZXpOVpYMo5jCQMX2
  31.190 +6S09JzKWs6kf6M4oszfyqTQ3wraqnq2E7NTm5mDTpYw2aM+XwNPrIrqyLCHt1kqp
  31.191 +BXHfF7wnSu8/QhOfnKCRpspwRrkqimXuGb2fbaYR/ySS7PaaG9wjQrLmZB0ZAq+I
  31.192 +xUXMkIzkOpOxzm2HUmqps2pl6PqaFK7annR+oocDsl07tSJnB6rLAHHOCna5AQ0E
  31.193 +Wl0zNwEIAN/DrhSP5Gq4L+EjvWXdq08CevJbb4k6vDqkIg4PiIP0Tj5o2y+sP0NJ
  31.194 +sO2CPhus1El0KdD98J06c1K6leJKMFSQVWXLbm055QXBZi4HEaCd8Y26Otv63t9U
  31.195 +CXaiEpUqAFuPr4GOY7GruyAkDA+DgYW77E2pPkXJLxsJtFoEcQ2hRSqBZ8a/56f+
  31.196 +ZrbIpdsvPG9CGVyXvrSLnYqWaixlKJZNx2lQRNo3pOgF/GkVMSOIpyxf9ERuZnsj
  31.197 +J9eIslj+oxcrNEfAWtqYNGO4NZlPf+hxl/tjp80bY8OXR9Xhiy7F59H/TY7hWRfs
  31.198 +ZFivOr2Fv1OWhwAWpVxFHSe0hkqDesMAEQEAAYkBPAQYAQgAJhYhBM7YCWrhIhaA
  31.199 +woSH/fd6hr7BO/PYBQJaXTM3AhsMBQkB4TOAAAoJEPd6hr7BO/PYXiQIAK4abIzA
  31.200 +L5A7xf9/oqxteKTpA3K7kR/hgURGexwazPyJpajx1Trm9mxE822CjQcNa8Yi+QyW
  31.201 +JoT5cPm9cOdcnId0mmHe33ihlLzd0Bs7XUwlowYqCOEWhCFlgnwsvSjGHfsqEasz
  31.202 +nH3HEa8ytl5mRvXfhaRkK2xvtureWUYwvxBiXryZ05rTqUm3dEGtoJ7ezQJFLrOM
  31.203 +y40DNlq6Ue7rw26MBa1dFw+OSt6eICmEaBym/swsyfQW6N7F5bronRIR/0bncF7C
  31.204 +52E02lb0Yd3M1BrJyj7d+d2ZHi4xArBJlKmCVBKnx7nnrcRGlt5RjSESIP0Nft/T
  31.205 +far7Mcqq0sSmyM+ZAQ0EWl0zWgEIAOEUgefeUVbPA1GrMuDrEO3dSSx1L3i3feZS
  31.206 +EVnMZrVas4ut6Z/bQbnZpzMRIvb7TG9Rz6c0Paw8e2ilyLNUzeAF1Mkx5yvFFe1e
  31.207 +QmeDZh2/uwvvsYbXPw0H5FjYn25yXI/MaFWicg1KnOSU16gcbugw84+L3tKPdRVE
  31.208 +YzBkG6nFM0F61P7LAM/RAWbS8CpYH76EhIuFsvsUNFPw6Ne+2pYso3oDa6uBT1Uc
  31.209 +WLXLlGzsb3x3HL1MNymRXAIBCmnvhAWEyAyAvrxNi0CMRLOrWuNI6yk7ORlvbxrh
  31.210 +qRKab/WFI9hglllu5R07kkLEmxxwGk2cSAYD8RT6aeR5SwC56hsAEQEAAbQxcEVw
  31.211 +IFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokB
  31.212 +VAQTAQgAPhYhBBQtOSjaIe8CoootThz1+OCQ9a7BBQJaXTNcAhsDBQkB4TOABQsJ
  31.213 +CAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEBz1+OCQ9a7BcNoH/0UZFWkdZbMtQE9d
  31.214 +JbECMEO7gDJhqudKiYoRPgi+7a0FBSk3QVG+Prj10fFlhMFbQ3gSBjHCfAgWEIyJ
  31.215 +E+ee38vL98vPqJyC6isu18fjtptYsK/+rN9gAHbOR7Kbfh9kkMuyZjB0mcAUPEHM
  31.216 +ig0hASZ3O8umtJZwnW2uwFGR1TOfJBrWkUZ6vA2y60Q7Yir+gKucF6wa9Bc2EVwL
  31.217 +yuIj56tNNlsfHsaWfU3A704lqzgxKjqkJ3S/Zvcw7aRFJ0WMj1Vda3zkQz3lZxHR
  31.218 +cEYqGukyEUXOxbEH5e1yDCeL7tsM7cJcyQ+D2tdDrB5Uk/4lNe+4wZc7ZDc2bgTn
  31.219 +PKCSStm5AQ0EWl0zXAEIAOdDlt6GC4zlwjrUSgmJJIaViehxFFCamo+b/Y3Kff4I
  31.220 +qcCJJe8k4gal6J8b8ezDpQXFuN/30gn1vBx5YlvmJDF2/Qo4Rd0eYzhPTkGyg1HB
  31.221 +UlMuowhRtECmfnhq7aY/bLPxsPuxNfVA0vtZ9FxPduqj/+32lQ/uBV536KElFtrN
  31.222 +kotsFQLu+9UTakts7cbT2i8ZrWQG8xlqONTR5xfqjZXeJ2f9i4DKN6ojcRvKWnqP
  31.223 +BU/vWuk23CApFP3LuLCi5xdHfitf1kya+ShkQ+5ycTqXThBe/NA6+h5vFY6PntTT
  31.224 +1GVcaEnNFK4uat1ey4xRSNcvFKLJN/aBkzPn0M70NcEAEQEAAYkBPAQYAQgAJhYh
  31.225 +BBQtOSjaIe8CoootThz1+OCQ9a7BBQJaXTNcAhsMBQkB4TOAAAoJEBz1+OCQ9a7B
  31.226 +Nz8H/RxEq4NR8WOB/sbs4+qN4aqKlb+zH2EyHMtXO0GJbrQZCYnUfQWf1NVF78zT
  31.227 +Xe7NS0vWAd8phIxWZU01UfF2uPc5AY/V2FpgkeMoR+1kMm4L9wP5rdWSKEnx78gh
  31.228 +o4J3uKYbJL27pHRIPLswrJy2aWiUUK2jSWbWZV3fOzzTywrNOYGzWQxag2Nbhmje
  31.229 +HdumD0wwXD4RNviunN3cgNrpRv1wHoIvxpUfYHfbyB9mjnmDDJGPh5mWWa2fDlfZ
  31.230 +uXP4/8HZbhScWj9a4HXpo58ULqtU5Cn3DHs5HQbsm+MEM85BRHEFRYhkbU3U2kGF
  31.231 +oEPWX+59d1doeLV3dEnxolEAaCKZAQ0EWl0zwAEIALf35c+3WYsMK/ZioVHECQIp
  31.232 +ZBXgXewPczKnPwY+ucQ2cBPdJpbNPmFSPoisuEgogl/Z/kGxJJBhjNvn08W8S9EM
  31.233 +UeQZTBMR6WOLE8ma1hyDgJGWlAUoCBh7VHvxquFMN/CIANwDc9ejVhh6Ng89ubhD
  31.234 +zvA5cggUaJrjJRDS17lCqtZwXZfGT+NPK4Ai0fjSSFRHOgzX/u1LM3Qw2oE0ex+g
  31.235 +9Lwdk4+y+/y+MqPwsUtKiYiAcMKRC+RaKTwjAVIocRCzFu7oJhN7+67HarvnxIGe
  31.236 +mRcf2RJvcpbcbzoSXdpOlCBX2GWgNIUgGNk9h/ONVu75braSkbaMNz13GtD1eDEA
  31.237 +EQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhv
  31.238 +ZmYub3JnPokBVAQTAQgAPhYhBP6ro2FethX+1KdyLHt9pda7H4GOBQJaXTPDAhsD
  31.239 +BQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEHt9pda7H4GOEF8IAIxG
  31.240 +Acvbollx6NGEdleQ2uJlHu0hL9j/LckV3Op7pP9YEwdA43GwQ7IazFXLmzOokvzN
  31.241 +e7UH12/NA0lL1LhGoxh/jXkERcrtejw/skoVcN7CeyUDR8aLAvrgCp78iCdLGQ/i
  31.242 +mKfT7Qmy7KXTbhncUXv71GeiaVneV6bv4RiFDcNt1wkOB+V0bYfuK9+EUtBFcJ6f
  31.243 +gH+/Zag09ASxNvQERNC9ggV4jtDNH9oQflGuY1dwna4v1Uk57GdI8NDPKFrIEQhv
  31.244 +WeaH92WEUxAczPNkBF2CMLZqmvHRCmQR6PBEAnM5DYiSkzbSnESV32FdI5BVHwY9
  31.245 +2J63fvvDL4iikrhvNGS5AQ0EWl0zwgEIALNKpv1ApSjIBp2w+5M1SWwIvDC7lnFZ
  31.246 +fTiwrYptJR44WMaulERerQVIyW+8BSPsVkUX3jTRnPJQQgObz0aLnwILmOOb3Y9b
  31.247 +njbZPOAyKvcdKKpo3mYV2Et54/ZAxhgoEFU3hhi5znHvY+Tdxz34+/C9jx5qpFPt
  31.248 +2IiODG2sapAj4FArErXW+SvlGI7iewERYT04uQ0k6yxBjs7QTqojD9ZfagYQ6kOA
  31.249 +W5zyUOLkY/G8pxOSAp9EBm1YJyI3mS+7cfyYAtqmZyv5ft5UvjrhclW31bv0eyiE
  31.250 +0z+q3yTNTurIzydOAZs+S+IdpdrM8UnQCE6PvPHb+l+mwU2Aq6auBLMAEQEAAYkB
  31.251 +PAQYAQgAJhYhBP6ro2FethX+1KdyLHt9pda7H4GOBQJaXTPCAhsMBQkB4TOAAAoJ
  31.252 +EHt9pda7H4GOpdYH/2MI62r9RRlkDNcRvp+hLVWVGInXOHiKtm248Q5PcGhY+Wfk
  31.253 +uiywe+7KpHIzVmJjOAjAEB07nYR2mf5a2tRguB6cZ2qfNqnN8atECMyncFL/sGrr
  31.254 +57kt09lUpSjGW9u4SARIYjGQBtEBkNKcrachjH/ZvnD1WnYoXYQ0ng+qeMmtg7BD
  31.255 +XySvn7Pflf9wbaSvgPdsaQ2N1hCST8N8dgPlxkE80aKT4xa3WKB8BSyrlOORnUhb
  31.256 +pTUo7xsjbNn7EZD09WdJ4wl7dOH/A5aJk3z9CMNmh4tYx8Gm2HCmL63AVh1yq12F
  31.257 +sWjq/4YcBZy2aGLHDPuwZ/3GHxqrJYZ1RdpJKVKZAQ0EWl0z1wEIAMZ+rxH0qTTN
  31.258 +dU2uDaW2CWf8XuBOHr6pbE55T58QETi/G/4JXn39wqt5TcqKe8p+aSqealncRFRq
  31.259 +20iiVGg2jKPyhlDz5XsPyVu+UZcMa7HqwZjl1mGPzrHibLfNi2TnHCR6Sxpha+Fd
  31.260 +sJhk8fkbTRPWgSxeQ0cYDMATFIxMLavk3GJ2uhqjfBKp8zowrOxrX2XYrpXKFI+d
  31.261 +3RstAdIo8sJGvr5OFAZ06vqUzlE3Hey2ux+zRoRp2B+MIZuFwE1Olbkvsct2yxSV
  31.262 +CV6FbeG7Xoo3Y0QeMLhNg6ctBWbo1nFc1SKgc0+LYf56yNUhRIjm6EkOXgJO/lZp
  31.263 +3GGz422K3Y8AEQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNp
  31.264 +cEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBCpmJ9rOPHpXYudMuGO5uXMOOlpN
  31.265 +BQJaXTPaAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEGO5uXMO
  31.266 +OlpNWKUH/ja40aq1nPlkg6yxNIErVU+q3g8K9YSE+N83rYFjLRb4gz9qRJhDIcmh
  31.267 +WrmRNSZcRgWteIFI+L75iVVfLYQo9NlBfJR6eaFJiMpeUYCmewppv2aj59n739LR
  31.268 +yws+TN6n5JG3XiXHo45SexbqU32xFXFNcJudegawHLKUJ9FYr1tegnkZB+fAGp7C
  31.269 +pFeqpIgCwUrfXV2GkJuhLUtsMx/sx0jBBwvWTI07eR64+wb052vuYgTYN/fNfBNG
  31.270 +3lzIVrkFPkDnzm0dWIutQ7kLiawoO+ArVuGtmwrcFUm1y6bQwQVftgNSdC2Ngbs8
  31.271 +otWU+SnvDXrsTMDVkjWwyZiCAoinTcq5AQ0EWl0z2QEIANwbK+RFBR02bWdejNlJ
  31.272 +vAa1XV37iq+jgdz20hbvPTpXcyx4H8oYBwksE054iDGl/LdK/kscF1ItvdXSpPEb
  31.273 +kxJv7Q4gyouk9+3sr8MFXa4FusfEisSUVzSSmYzVY0+GNjUy9fQURryhUQRp31PU
  31.274 +etYEmrQ0G2PKohxzvWclNEfbK/KUjA+I72o4hA/AXwnaT4QbIAvBbl4YjGpr8w/m
  31.275 +hcJ5BQF1ny7aTCgOHx9USNTq0q5wxm6wOP+nMpArMthg1rJg/95IdjcGB0dhrIfH
  31.276 +4PXGAN9T5Zg+TUY+OMJN1f2/tT+hBOKhQblcHNKxCPPbS2lRzJ/+BmMhAPbzJbv5
  31.277 +6o8AEQEAAYkBPAQYAQgAJhYhBCpmJ9rOPHpXYudMuGO5uXMOOlpNBQJaXTPZAhsM
  31.278 +BQkB4TOAAAoJEGO5uXMOOlpNU8QH+QG2AnqGe0WVCTk7yG+DzETgBUiua5O7tyzW
  31.279 +MpstHgFs0B7f62+AcziMPwxdtvkpU97IvEZIcrSA9otdrk7w6XoIqzG4nlHs0LZO
  31.280 +VOetuA4ohXP/SYeK/Srn5zH8fpj4snVBSvMfp5xoNFobcQMgXjZnFICTVX/Nq5lz
  31.281 +6ovaclcAzgTp+qAk0wmOfFa4t4gOg8uCru6RVKdLei68Shebl3T1Ch/gJzjCsEcQ
  31.282 +jQh7t9fpW8pUcDfJKaCLYjJncyKoNOphRbAZDx2/jPihQMg1Ok+ZTDPALB+RXU76
  31.283 ++LbDu8F/B5uLvTLqhNb9ERJ31gcOoexo/F+L/LKBX0iCbmdx4FyZAQ0EWl01oQEI
  31.284 +AM+fiDqAWdm+q77FfAO8Nd6AcJwTJl850VT9ejtTLwkOQ18BX3fORJko23Fzz5WO
  31.285 +sHiNJDce6v2l+0XvmtX/kqPRxH/XhZuzChJXkS5SE86XH+5yYq+5XXd7s6X0plBv
  31.286 +gYmEDj+zFZgjXEUYUuacKWy+e0kbK7RaQiqSyEFObtTa2vRqbRc6WAirufsjiG0B
  31.287 +wCg3RMB9ffNd8sA0rdDYsTMviJBfck8aap4K/5ROZU/eB4pXTlwTExbMkK1cyGMA
  31.288 +JHZ1O/XA/D5MLkqcIbu2SIpM3vZcX+m4F0pl/8N/OKYLSO4ru6v8DnhEMg2NpENy
  31.289 +GIPHDW/sHQ2sID7Hfyl6m7UAEQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAu
  31.290 +dGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBFTIHdH1N0eSB3th
  31.291 ++VgZdUZP+HKfBQJaXTWjAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheA
  31.292 +AAoJEFgZdUZP+HKfL7UH/2r/d9M8JRuXVG4to0YBF9nhtL2wG7cl/5NHLRQ+91nb
  31.293 +qA07/QZziQs7sq5ot2XKYC3N2NUmIHDE3hMWzM3dG2plN7/xvtaFdNo41HtlnWNb
  31.294 ++bMKfj91bybu++2BCoRfwWtHUwlkjYcXF/AxiA46qj6UmBYEcEPiaiLObgH0TJ+D
  31.295 +8Xo64UP3c36gs6sFK5T068XQ9TYj6YdNA62YOukxoc/0iaVRAeKm7cnUcCpxoRjy
  31.296 +beo+6Q/Ncd3yCN63FY3kxxeHvkYluC3yNWbnMFl7Mmh1GBXx23yVfWscor4IkomX
  31.297 +2Ue00ptxut65reUxlXvDq4UUX2O54DVQMeJUCzpkMG+5AQ0EWl01owEIAK+9gJUr
  31.298 +odadwHVXDIPosjgDyVGSYXWMxb6ajHKZLc1Pb4/K7TNGo0Qo+VtT1TepueC1FHHS
  31.299 +WHpjgpV8TJlUFzcPtPobZ33jLPDIpolojPamXXEkfRp5epQ/0ppR3MYrzRQDS5Z8
  31.300 +mS1lpD/A8jrQVmCQMXZEJzA/lDP+oX2mHLvA9CRoRUjoIzpvQvAqKe/dLDmpfjfm
  31.301 +c2I3W9cpAiQM7gyGFr3Hbpi5NCde8dqC0Zvv7mGQaPSLYFsW/fXAlhMiBauCZ5XU
  31.302 +TyG9dLmIdUW4TAVu23NKoAdsdQFCmAJX+1nK+cGAw3bPdDGnLCmsFtjWYPEc9JQc
  31.303 +4Brvk8bAOpk7kbUAEQEAAYkBPAQYAQgAJhYhBFTIHdH1N0eSB3th+VgZdUZP+HKf
  31.304 +BQJaXTWjAhsMBQkB4TOAAAoJEFgZdUZP+HKfjowH/iczZntv6yCeGn09xWPsLpga
  31.305 +fF4r6rLr4FD4q+XRerDvHnHNb87fKVEE7iA0YjR6ZeRo14Ps0F/fU4nSsBWA7FzP
  31.306 +bPiMmW9Ex9NhxXqSEmNt82gmkqsD7jkcjqXzZr+gFFwOt8nTRAKoHjdVWIyGKPUo
  31.307 +rigSJqfwsMTPKFjvCEV2F/QyWocpBc5Z5wp1nI9mrWKdFK4BVhMKCJp2LfDwZEcy
  31.308 +exq9XHTx6mpKKT4jOkgr+7/ubfStlYycQdOxrbKAUmwyJRuVExTYu5vuMQQ8MYS+
  31.309 +hfQX1u/wczMHtBIcfGO1EKKIlY6EG1Iza0sXFUvJkefytbDzI0SRWnV7G8Qo8l6Z
  31.310 +AQ0EWl01wAEIALPtHDY3PPmF6v2E2S+GwjFQgtc7EoiZBFE2ohZxM3N7k+sw5bAd
  31.311 +wRVtivugTgItp1eK9+VkJBiGtMbf0e2AIMOrZO7Rd2yyud3C/vbsjDZsDpsxqQ+j
  31.312 +jzlfaHd6hwIeOKrYNtWEQi1FlBA9FK0ho3t5N1/pECRSh0tKhrXr5gGKuAmxJVot
  31.313 +aQYhXx0ymLL7e7wNQ2FfMHW6za/ywU3mBcjoNiOXDu+xwwKOJrdxtMFwxzahOX+n
  31.314 +fGs0oUACRurHW549hs+y7N23617F1TPWxd4DL/8MVVMyopLqJmZnBt0TvzDjY8Rw
  31.315 +ph11dQFhF3Cvstf0op0vKa7QDuzmcqM9lbcAEQEAAbQxcEVwIFRlc3QgUmVjaXBp
  31.316 +ZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBNRL
  31.317 +LWZED38Zcro7RZiEXHo3UiiKBQJaXTXDAhsDBQkB4TOABQsJCAcCBhUICQoLAgQW
  31.318 +AgMBAh4BAheAAAoJEJiEXHo3UiiKgywH/jA3RGu85kOoJvqij2qe/Xn+VEg59Hn5
  31.319 +A8jh5v5mM7sDw7JCoBeeSIwL7snGJJ94kjQv5Phqgrg2UKcIMDEpOQpgmjRF8tbe
  31.320 +vS7kcQGBBVbRc4qJ3w5R4Epd3NCHdfZCxRuCGuXS8mNh7QtxbJHRBocQNGTto6Mp
  31.321 +36Zgu6fU40mO+JbOlEDV3Fm6vxJaQ9WT3Tr4Bvx8Y7MHtaOQtYjXOENhTrz9rJGC
  31.322 +jW3eMhJkpV8v/wQAJufrqUiq7VMlIt9nzyNArCrnG3xHSKWJFA6fOFBioi6TEGma
  31.323 +hkwZRdw0pkP+4FGhj/+cFuWWEGsw+UFOHlhEKsBY/HukIogwtErSpku5AQ0EWl01
  31.324 +wgEIAMmx5C+2/+NjMpxHM+T47F7wKOP75do4SuJrLTgm/f3m66eqV19LwEfEUDTQ
  31.325 +H0GwHBUUnoW1G9HWTC7ZiGpA/dVb8hrKyJDVjBp1YXT7oFg/O0UqwWpnQuiRFsQ4
  31.326 +O1Nw3wtwWHBTWrOHszpMKWpWrE6FTpdpublPLBmlyLpYIblvnskoK+WpJErryIfe
  31.327 +HIpOoBHhlCt+NEeOwKY1CSC3p1zd9cf+pUdnA5aZMRPIAq3JYJMz2FkufBFicNOc
  31.328 +NkO6TxEovNg+i8DDl/Ssjvl0KahMH9BrLlfVXLoWdRQG5CDXBiSmjfa4XVF9Q9/+
  31.329 +nFgnCLpVxwqK95H9qZ2Vyko8Wy0AEQEAAYkBPAQYAQgAJhYhBNRLLWZED38Zcro7
  31.330 +RZiEXHo3UiiKBQJaXTXCAhsMBQkB4TOAAAoJEJiEXHo3UiiKRn0H/3bl8spXmLbK
  31.331 +X/KazulNRLrU3HOam5MNbA/pwkzQ33AttULWkOC/lBlBfjPtkLJrqidLf7ptxPG0
  31.332 +59sZzKU7TPMuYibPolzcFuBi0Wyx9cOkssDxubtqLEo9fAqn/plD0XAHHlM70O1p
  31.333 +Yr5b+fHJbesz4BXFrKW7mdtOso5XV7oFGfO2n2zruwyAQP1E6INHISmbUdskKPLi
  31.334 +FPIuzYDY2QOUYOj1rH2zeKnlAybKYfmO/UHitRkOh2NfRRLb3phfDcRvxOCeXf3p
  31.335 +HSjUVGpdaMNr2+8fexxdTIT84ZqIqmCWopI/Tv9HcME+KtY3t6YfuQMoaDwjJIP3
  31.336 +mLyHf6hPUxyZAQ0EWl02NAEIAMIxf0qzipLSYHbIJzAwrMsZLJgRZJQb0deQytqJ
  31.337 +MKZsvyP8a8JusvHM1SF1jT9lOvkVHytlfer9wNlXxn8gUQD9ScvWcoACZpOW56mR
  31.338 +GhVxVVQnWuZf8a7sbktw7JZ/kLaxZ+E6W7z9M0BWnYD62Hi5+AAz8FZG+sXAcU2w
  31.339 +aZNWCoFj4RqOJPB9x5ebKdOcybwYONlVAyeV9nqk/Xe/DVBpsA7/cbafHtELQJgb
  31.340 +AsqVWeu1DoBYEKPZB5hzWM5CHRFx8HYXc6CsA2+RED/NoH/fl92YiWuzcsL14CiX
  31.341 +NmcLzKdD8khyypgv5UA84XNnti4M9uUSndXB4lbx2V/n0MMAEQEAAbQxcEVwIFRl
  31.342 +c3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQT
  31.343 +AQgAPhYhBLwTTmTPjEfBVh6+T/P2h9zIQ4IMBQJaXTY3AhsDBQkB4TOABQsJCAcC
  31.344 +BhUICQoLAgQWAgMBAh4BAheAAAoJEPP2h9zIQ4IMvF4IALzAjdWaFTXQcHnokY7o
  31.345 +5otLJmOatirnr3P7fPQbhHgeobXwhAQxQeq9OTPzfN6LVL4d9pNjARx324N12bks
  31.346 +0kV37oSeBeoKSkHhKwQpeQIOUA6wuRdm4Ka6Nq+1wRPhZYlRwCZGqZQL7xMrwqLM
  31.347 +L2bI1ZEeAHum2E0T6mRxR3dyr+Xko8E2E+wy46jpbTOUKa2VrxSrjqESpbGMXVGt
  31.348 +giJ4ig2fL4uG0aSlpl3TkzGmaRYwS53J2MhlKsMTVb4EOg8zxUEiGkCqoUAIKIGA
  31.349 +ifDWYpTIuMJduSIIPBf1ITM7gBlI0hv/INIBSejGOEoK5/d4qtYCb+5UZSvHSLI/
  31.350 +jri5AQ0EWl02NgEIAKsjvnOgFetfKaRo0X6wc+mxTXEnaw+U8+LG2mBz7CTFDlcy
  31.351 +LnjTR/Dky0av3MLQ64CSBe+OLp/0SqXTAMxodNK8Xx/sut+MxrImi5k1hco3G/Uu
  31.352 +b8nmCdkSrAwdnkOwiGhGwZJf9hyU6djTOZJ534NxNIq6X44Z/rwGUIiB1hMer/uz
  31.353 +XVzentw1dld+sYvkjOp6fJu5Xz5wwiFFLHDeRj8cxL8HpWmZGkWgYAo0HKEE3cRI
  31.354 +3knJBZounmX+29kFaks1/9ulORveS/qf3ffnhigeD2b0Yh9Zkojl3DoURbel704w
  31.355 +AfcQl/CfZR5H9h1JqxjQ4YEY26s2OKFbFX0RQb0AEQEAAYkBPAQYAQgAJhYhBLwT
  31.356 +TmTPjEfBVh6+T/P2h9zIQ4IMBQJaXTY2AhsMBQkB4TOAAAoJEPP2h9zIQ4IMFdcI
  31.357 +ALqGBDUmSZzDV69VM9835cyD0nz9Uu7C68nwkeVpW4koo+BbOiirOek8DH+knV3B
  31.358 +8yhFpw1dkWiJWBTYinmJ/sba3J7q6Nk1s0bmJXjJCtFBaanUncY0ybBfJlu9sOuz
  31.359 +WXLxUf2CcK2iGebgzcaeOUnbUjbrFGhp4oKy/9OsKX0YMd35ahjzvE2Qi+qR9WCI
  31.360 +fVk9vvRcD7dhBHCsOaUnwThLuIZ86wyJkRbtDm3tQyqrwB8oS1aAgBEvtZVRud9x
  31.361 +wOAA4DmWLjBliVebNkyl2fLj+oC13vTPV2D0MfD61w5kSrkOn/hZsnzLfz2J8Bg+
  31.362 +GFej3myZ/+f8P80Ro+kidYWZAQ0EWl02YgEIAKzVegNE71UBwexUA0zPnBbvmqh1
  31.363 +xu2/IUT8oNozI4SAvD9CcXdk8nYr8ExNM/XjauIxA2cSUqZP7jPpEhHogVhScy8b
  31.364 +8qCcIPDP0Php0aayZ+r+s9P+fotOMnFZAvDFrq4LQhO5TCKpGEyrVNyYdgq6chaI
  31.365 +pnCdz2apvP7QPk9rqbztVSDNfQkszawNvGnhhpBIfYroCCECMxMKiNF/HUVFXOpf
  31.366 +1dWeiwdqE99fc31fWbBGR+gajdMIIuWy4gF1RPi2X2id7OZJ0aIDsVznXoBFsmWy
  31.367 +JvsBpxuI3+6OZ+se06rXp8ujSKsJjg3ce5EpqnnChydAOXEwYzf2V+MM6jsAEQEA
  31.368 +AbQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYu
  31.369 +b3JnPokBVAQTAQgAPhYhBJ5hMe0jF8K3mSp4ImK9mmZxxvLEBQJaXTZkAhsDBQkB
  31.370 +4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEGK9mmZxxvLEZ5IH/0apXr6C
  31.371 +H5nC4T9Id0vm/PJNbMweoq0RfK7pcGuOvQff3QE8Rhlicjgaw81sJm7iqiMQLhiG
  31.372 +AGCGFd+4C7o6tO/JRDG50n2xYzUyfgcrHR6IdMKPPKh3SxYidqpra7YNW6zyJwZP
  31.373 +BqaUyciSOEoy36KBVDEciup39ky6DcSG9Hn+fhIx91BPPZzGIUXj3JPUH+M/bq1d
  31.374 +iQ3+nc874jMmvfwhYTZok6rzJakXRNYUjskqanU2oAWJxWWBDo3DsRVtfy7Sy2GD
  31.375 +6iWbfU/+SwDDAdmh+dCLBzZZuQFlqQC3MA4gS3qihLXk1YgzwJq7LP5afYl3uslJ
  31.376 +uNvhMztF9iBKLDa5AQ0EWl02ZAEIAMg3k3sXxi+cc0/ncgsh/2N+JjAuhn7FGmmR
  31.377 +RABZkQh6nbN3qmqfJd/IJmlpTxOGfMnz9/dLjEjRc296HoITtPqa/m/l7EtmQDue
  31.378 +Qyl0u7ikXzkhSjxyHHC5lKMok7H35EEluJz+tYz+gvfiRMOK8BDdR3BS6PvQozFn
  31.379 +XmxwqbI0u0i933XnLobeWKeYSnQ+JhsIqJBR8Ri0py9rti/ZsXxJ+JqXiqDHK+dG
  31.380 +gzlwBtE6UBhIM4FyOWM7u54GHCEEPX0W144A6cvrC1xwDrIkdnzZuh+RKMugmMjt
  31.381 +mt/zMocQbCNa0McCxcEQqdDZVejk71NiGSpdVkv4gHOhae2bojcAEQEAAYkBPAQY
  31.382 +AQgAJhYhBJ5hMe0jF8K3mSp4ImK9mmZxxvLEBQJaXTZkAhsMBQkB4TOAAAoJEGK9
  31.383 +mmZxxvLEdIMH/jlMBa0+FoDxCGToSV0iTQL/5rOTSi0gsGWwqGkab44uqPGXx+wl
  31.384 +wq61G4W6hT3xwsfj+HBtCdGQG82l1yBf16OevtQe1QqPczZ7zBcidgNcXq9Czsav
  31.385 +wrsc/vHV7g7AC/VHM2cUXcud6yTCQHXGrzWrMm+lfmhPIfU5ZmrTzRkNO2yCgfDf
  31.386 +5szX1jx1r1QciBizsjHoZ98LArdsZxXKYQOqHhE+JZ+/RBCIyCK++iypFUddPy9/
  31.387 +dOAmnOmCx8OXViBcchnqUn5XOLzWsVHVa9XIeHSemStz/+T7HeOsMKtA07oUXt0m
  31.388 +CmVnlzQnArRKY/7Ce6WXnY168d38yEcuVFKZAQ0EWl02cwEIALasLtLlRCbPDtki
  31.389 +7xWxh23u2lzd7Py/Rn3KhT6daFKEcUSmeT4pcAenf5cBCRiJ5RdnzTuJybg/KI9/
  31.390 +9WOk9uKkmJEllCB4rJaoFn9eOSxd5lYmeS4x8Fdk0h55j3FG8tWabd12fUfcsyxH
  31.391 +ZQdrYR+NpzkRWH7xy7xAaOMj2FCau+leB/mud5A5aLQdslPT/3mkTNBm6mEV6BPI
  31.392 +bH50+nmuwvV/jhfzco/+d2dnCrFQlaS4G5UOBhEYYSqVHxvqjacyhSbJy4uV2aVC
  31.393 +ZchJqjuICDbNwjbkNvtQiKkNPR/E0Kvve6OGuDgKueL4jxjHzkxMAYYZzmLe52yC
  31.394 +ADZqso0AEQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBr
  31.395 +Z3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBIuLowA72bEAwwwcHVJbUFKMMI7wBQJa
  31.396 +XTZ2AhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEFJbUFKMMI7w
  31.397 +X74H/A2cZtaBm4GbRut3V7R8nR4SHL+c6rdU4dFnwZw5KxArVdHxpnaXlqyzzRcb
  31.398 +K5vE3+ZDwMDe4m749RVVbW+ii/lMDrVxi/ApogszwXALbI/qI7un5KWCzP/wQtym
  31.399 +3HBDKcSfwdmkfM2c8D9dFk3/MHXjl8jCOkScRGcwmyahOKIClojgdYdgeztWi32d
  31.400 +4+HLJcHUOpUEVlybblzFQAv92dmvLqUwfgm4EiUB3DQad3uULn7F5oT69Sl75EBD
  31.401 +TFckJik2W76fq3xzxpXjYurqfgJlDEhWc+drspf+ta2CkrWnEz16MJH9fJRHqCf9
  31.402 +LEgA8u62evv8xTgOnMXvAw56Hpi5AQ0EWl02dQEIAL4rIAxvAy7EbZakUIbvI/7G
  31.403 +hnek3Cna9Byl64wo1ZQ2rYC9oJsqLcySOhzTtMSaTy1U8+nZZhzmyh9+f9zk4htx
  31.404 +8QPHaCwzGmy+tzJRAonH4WQHCXSMczbqbznxGHZ3LBu9YEQcs97zpiqFu+F5oz+o
  31.405 +r1wjIXOSVNTtaWzmLDnLMwf6fzM+uaaYIqeLbInbHU4E+D8YWIuqo+VL6NsWULPT
  31.406 +COovNIIetgtHESZHUwfjqTPoyan/+aJPsztmCrDW24UO+/KDHuLnMArkCMQg1DPq
  31.407 +apmXGT+NEs3LrHtwzQGtqG5dLl5/Z2TBrOUc3L/sKi+FJIANjkZtYTnUpCV7wIsA
  31.408 +EQEAAYkBPAQYAQgAJhYhBIuLowA72bEAwwwcHVJbUFKMMI7wBQJaXTZ1AhsMBQkB
  31.409 +4TOAAAoJEFJbUFKMMI7w05QH/joFvdYvykTSVb9P3hvSSly673Jqt/3GzNCYbKGn
  31.410 +iUgeGRPVS4iSMm0xFrA7ScKXdMsRfpk+6ZpZzEzvdoSf46cYDE0dwp2KbS/GzP98
  31.411 +2jNCIN1vytYatBUe2oN4dmmXBdHvlHUVeX1xvdwQqnN/yO8oqBbT2IzJ4Zpd0bdG
  31.412 +TiKYUU3FYUVGPiANdThIwOn2m5dRsyNj0n/WgjHeOLWOft75DjAmFOv0SiQ8XVk3
  31.413 +AwRSrCeYlXofpZjwYc+ty9NMLzkMEQCK+3i5aQ9+1is5w4d/88gM7bd34Ji+NEi3
  31.414 +GXM1fVraRsolCVC4WSUXl3nmlLMV+ZHQwxE/lHdzqJ3ADxmZAQ0EWl032AEIALnp
  31.415 +eEqmfZZ/tSYbdNNItDnlzvDiPa7Utu/8/gB0odbncKnBlPOK/eqtEEw4jwjE3PlA
  31.416 +3kiZJ4zUjWxTzvVsGq5/U9qjZoB2e+Zzyv38XDffHIaM+xtj4LvTZgSNqwQl2j4E
  31.417 +xbxkVnbuXbqiHt8alnv6tJ7BZLKxTlud77IVfcm/gCmEaWCXMM7M4NBnFtqTD18g
  31.418 +QqKSA+IDyRz0K0DFe9O771gk61u/NgoD5kfDdVSMDFq7oIauWilf2Ava4VBSs3fJ
  31.419 +h7ii/R5yt2zz0GL8CPB9vIFNdDkHHc6cI837Y4ZnJez2vHlddQnNgjP6sqindVf+
  31.420 +vH2svviV1LtYrfDm3zkAEQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVz
  31.421 +dC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBJvDAMMpGZEcItz82Gcj
  31.422 +6LnSLrdoBQJaXTfaAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJ
  31.423 +EGcj6LnSLrdo0IYH/3KLv37+7CqZZl4z65OH6Umc4qAbBJmvfegY8KezjSH5UsLH
  31.424 +skAskVNx9QHp0X3KyyLezIJfMhTFvCYxhIa6sABO2sXfRSBAhVbydIF+AENxyN6n
  31.425 +W4llOx/IuX9OvB05kvhQ43Ngj36HAhnMnpLg6c4eo9bQhhvoKJZXuivR0wWUQIZz
  31.426 +AbZNaEp8+B4GYVEclojvTc07bJwsaIloQh1MtWRbT+OZkeJOxB+15Sluq/AZA9y5
  31.427 +FEZ17Tpz/ls/5o9W4HCUbHoK5/IY+5qMw8O5ziQR9NKhE4kv58+n35MtGPUf80To
  31.428 +dbfsOC6OVHKbeuVoDGBNRedPjQqukt/qevVtrdS5AQ0EWl032gEIAMxAcyz2VwB5
  31.429 +IHQ5FrtnN7vTS0iD89LbuZrIcd9Ch6RrbrCsHgGv9581DmPsNsa7yRkzotXi0S1/
  31.430 +dWbk8JdUpMYxeDl+fNQfydnm1qO3O4kdeaCpqeocacjwNiOYi7vyxLK1Gh9ddOQe
  31.431 +JQS6FL/w+wxUkm+uHp9+yVEz1m218sWIlANeC04nLiN6JQkXOkd4wMhAuAKnSbw/
  31.432 +uAqBWNEjEXsGqemyxgHdEuEa+utJ2X3HRwd0cKo3m2LVtghEmpIji1QRCtBMuP2f
  31.433 +7ItY5FMiTkDlURoUJ21GdBI/im3aHoDi+6BV8IF/l30tu4VmmB5LjqwS2kxS5tUA
  31.434 +8DJsjHJ7UZMAEQEAAYkBPAQYAQgAJhYhBJvDAMMpGZEcItz82Gcj6LnSLrdoBQJa
  31.435 +XTfaAhsMBQkB4TOAAAoJEGcj6LnSLrdooO0IAJx6L50lzIq1pXcrX3gOX3m3f3xf
  31.436 +yn1Qc/kPf4e/m5ZvOu9PkqKeSOl8WIpAAC/ODmO06twndUp0UXL9Gq7NwXTt2lSc
  31.437 +vwI+ldCmGZKvBAmap+5AIAZBrpfIFnZUohKegVQ1ULwGrNXNje4towjz1LRlYsVo
  31.438 +py1cx+YcRuK2rAQFz7H75RlKkCGY2dFvgqZfTD8pG1DVy7H6SYavUHE0iq6AAB/A
  31.439 +2TWqI8jtYH1iIZ+BFkYRX7NlDZG7aXqRCtPQ84SI9ngL3r5U1CTjTpttouRM1fqd
  31.440 +Ek6t+vg9sMLxV8l3XIZBJv/91z0ZfHfnwRXK7yF9pAnwM6rq4DiBituvJeOZAQ0E
  31.441 +Wl08FgEIAJkkTpiMg7snOkmWNyxSYjrgQfGz6fAK5JC8/CAvTUeYZAd53ggiFV9c
  31.442 +Bvkm9YvDRCm1o+Y488GRXEl06qIsSoWavhpDSBhQAe8ZTmEuYubPZxgLQ+wP2AP/
  31.443 +ZLbKb52R/oQ14XctZwn4fSp7p25ZwKNiMbMuILn1tMiBbw7ZtmoxiyUjgYNgBAA/
  31.444 +YN4eMjyBJBj9I+QA9seFHLfBwOIJSCLeGPMr/cUIcZMycUl9yTiXqsb+t4mjll4g
  31.445 +eZo3qBhUf0YMV3qOfQK0oW2twyt5oTEr7iOZT/ygijkWKf+wpmIlBjvaIVnFsXoJ
  31.446 +zsh8cISPigEtPxPi5fMA3Ba0M21zyzsAEQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50
  31.447 +IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBFWeMm2Y
  31.448 +X2cVy918pjHwlFqWXQ80BQJaXTwYAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMB
  31.449 +Ah4BAheAAAoJEDHwlFqWXQ80ENcH/1I9j73A38P6VyRX5K6J/RImAJQ15CInoF3w
  31.450 +wskO1b5Z2aOB9QP0lZFGK8d3KS2Ix5ZHSgC0SfjaaFLOdWSd+cEXF8wyNWkLsUFd
  31.451 +MXgnBwpLWiTI0JA3+21cvq/zX80cvtGdnch6p4DdzZMJzIK4uv3LUk+JFj2V+iwy
  31.452 +HcLo//q591VlQMh4hj/2vvXIusLDAlPKiV5ub84Mw2dg0m4JXIWSovrh3VmShvB5
  31.453 +ETgsWVB3fjugFtyKgGZx8UHQY8m8GTFP51zYF/W23QkPWgnlPYdXoF/cEGkUoOQ0
  31.454 +aEf2k2nNGAZmG2lIIfhhLRgSCrHFoRLNsKelamyU5ep+8qqz6jW5AQ0EWl08GAEI
  31.455 +AM+hfs/2b3GzJCj3DFOLhGzapO1cTf7frjVmaMja553uin+lHnM3eQJTq9w5zKJn
  31.456 +plLRYf7Lw9YvdsfVLoIvD/wuXnfherCWk7dqdaSqSCD6Fx8hzM611lb0u7O4OH98
  31.457 +YmyYAOl3wMfTZ4XSQWd1+169tzS95IG1hiPCjKhP7LsRHgYvg9rXajaT+lFfhJcp
  31.458 +pazkWpDEP6ubF2rsJH+1hRk6A7in67gbYyZ/9cBB54u2aCXqnktTouikYb54oea5
  31.459 +7dGg5BXWmo2FEJgjRUZqLx6cogvIKOOpcVHM0A/Mgdsll5Acbnn09Nbla7rsqEmr
  31.460 +V76M7DIEiP8BtAJSCyyav5UAEQEAAYkBPAQYAQgAJhYhBFWeMm2YX2cVy918pjHw
  31.461 +lFqWXQ80BQJaXTwYAhsMBQkB4TOAAAoJEDHwlFqWXQ80CWkH+gMm2oteVBAHWBeR
  31.462 +6jdr3vH3afvpEc9EKxyHm6cB8qh6a7FrhXxPWsekaNNsN5iysO+wPNmsUkTh912R
  31.463 +AePDtciUOquY73A7VJRxjoWKTGMF0lA3MUbB1r7RB+By0HOHe51WP9FrqZVoWqdA
  31.464 +H3senp6N1Ti/yNmq9yxa98LnHPX7Dt6894aab7CtoOB2gZlu3YT3RMLB0tHBF/Zd
  31.465 +fwGXXDX+w+c6prHQTaQ5s6DEdvGxYAKKUMmxFshokwqNa7NDZx9h0IRlityqBOPG
  31.466 +YFp2u0ko82nccD2R6Mk4iaXqveuoBphNldV32Vira2qJ3/TQXHEBW+gdR9X28AuH
  31.467 +ZWwfHIKZAQ0EWl09LAEIAOM9HMjcX8JqXEz8exPZqAb3xmlRd2J+RbsA8yrtgP7y
  31.468 +K9zhvE/fjrFAOOvjTyO5C7VlWpmMNFF+z+T3hzx0phBKFuVEbP3e4WGdnVxfYtML
  31.469 +gGu20tUBg1yrvpAM1Lkt+Zj05XSjq6aSqv3LCya0w0mYSWsBvlnHkReQBPiy+lg8
  31.470 +rTmgCJmFHb/ioxnUOJcLCygP+zYluCTK+v+OY7mMSRmtUXNXDQr5bMkKkPsv0NMv
  31.471 +1jBrbsmBBoai/ZX6A07Nu5JaO9c8mPA+RQbePTlamh7+05PBEAJi6zTl7tA4bT1C
  31.472 +6RAMdkocwI3tIg7BRXQMHNwkgsGeo9oRb3Ycm52kjycAEQEAAbQxcEVwIFRlc3Qg
  31.473 +UmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgA
  31.474 +PhYhBKvftzRxY/2lvaRA+aKXVQGGzRfMBQJaXT0uAhsDBQkB4TOABQsJCAcCBhUI
  31.475 +CQoLAgQWAgMBAh4BAheAAAoJEKKXVQGGzRfMrecH/ixP6JLlErczQ1GlbUIwZ+Sy
  31.476 +H3+Z4pCtj2FiY7iqiKxPcGRDDaQqcMFbiJBZxWHrL5s6xaaZhx/JqZX4kgGFrtWo
  31.477 +WuZhJuOscYvE5ODBvc5YNsvuKUSK3TIyfcpx6KGy4dpzkXYvhXh0Gk1u/s1Mfm9i
  31.478 +GWt25G1OjcaYyKIeeZJ9RGzFy5bV5+h1zp8/6HUTSF6+KtoUEdP79VBU9y0N32EJ
  31.479 +HSrHBurirlAF4lofSrkFHpCR2lp94Sc0j5xhMsGoViif/YX3rCZc8Xk+rRhUneQ5
  31.480 +3CkreGYvJbNrgVGAcyGY/BHjAp9vN8k7XlpxHCNpT3hLp1cENVn///pVHQtJN4m5
  31.481 +AQ0EWl09LgEIANYjHpX6nmppT5thflO8ATgt3qP7mBIAoqHE5xdxdhAwRi/TbJv1
  31.482 +C5Oz1WUPT5GxeqvIPB6JNXQJfJx6u87nVxF/sKHXRUUTxiuxGRA8zlu6VbVP7TSl
  31.483 +hpGT5Geuxa/Q6GPsC2ikytSs5F0cB2kexMUTdVaUCrfItCameqlIk15hcNrZ+99a
  31.484 +M2E6M5zSjcLu5Rspzn6f8JWh9dpIMucUt7N81kCxB2kFKe/ztrc3p0Y+xNvqlsvo
  31.485 +9OavV1ig+fPhfUFnLT9GXLOEWhyah6VSGQO00jPTokWAiFf70oQVZqa/QsSp7fp+
  31.486 +rlprvdxeTxfUqFARPQpVyaT8FZePPWa3VjsAEQEAAYkBPAQYAQgAJhYhBKvftzRx
  31.487 +Y/2lvaRA+aKXVQGGzRfMBQJaXT0uAhsMBQkB4TOAAAoJEKKXVQGGzRfM/fwH/1IP
  31.488 +76DFiW1q/dA6Fb0kbpwrfQ6y6nUZ9hFAItPQnddFGeJoRJvhFFOSVexJSHI86+Mo
  31.489 +m8EIY9ALnaKInsPcX18iQg8E9oARj3pWDScVu5Sx5aswbjyaz6vMX7UuMU9juNT3
  31.490 +qhdZKZaCGWozIyOZTPwuTR8W8UR+3PgOklrGx5UaN0L9iqNWxqKst1Ku1tQJ1YDf
  31.491 +zQwdQ37Z6jqNyhmkjAil/1faBztmpZ+fd7iEpdCLKBlEL1/oqQ1J0/OUGquFIgi5
  31.492 +dbneh1vWUoVo1fqfI6P7YcGzhDYiZs+99a7q7KlkFV2jJFy51ep0xIdhRg8wT3Il
  31.493 +o2PE4DZzIoBgBQuCcP6ZAQ0EWl09QAEIAO2Sz9zvjza/8iW2RBf+inH2nywR8+hA
  31.494 +twlQ1vBM4+1M6H5mChKSkD8dqrsrkAMfOSSb8VsjIZ5KKUK1CVoacPwrscudEYwS
  31.495 +C8jCKCl2YgfzyM4ue/7LPJMVaCfXuiyfzoA6zMYU0juvVxiIoiTOlxZjHBL+XGPG
  31.496 +67uaAAvHuuwZw7MjtC6S0IkpfvTrCM76ZwBF4IvpiP4H/+6sgVqmVqLyq1ZwUHyI
  31.497 +dB2L7MWj5ToeFKgzoAuahts3sGk44e11X1OP+ivkT2nl77XG0udeQDzZAtWNyfiR
  31.498 +mu9AYcL2zNKYS0hmwj9N4drPJTGMZm2flnyFpeF8YgH5g60s5utsc0kAEQEAAbQx
  31.499 +cEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3Jn
  31.500 +PokBVAQTAQgAPhYhBCpeTdqGcjSFIILmeLxsGX3TyqCGBQJaXT1DAhsDBQkB4TOA
  31.501 +BQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJELxsGX3TyqCG1hIH/j3BEDqCQZl0
  31.502 +eBpIgl7tMnFTV+hKDMaZqGSrLJ2Eir6qClTDcTNeWKhqmZ6eOTHvYWcRb6d9qzPX
  31.503 +q3CRK6KLaKd/uSWdGe/2QE3A4szgFM3b/fGibhvlBBuErhpbOb/QROs6ffG7CC+z
  31.504 +PXFzA6ag0HFvs4+MCKeB8X3HQ2yIFloM6Gfun+hEedCfgNiLV/1Gi9UlHe0fR+J4
  31.505 +nV/LZjyRrEBQuCJc8QnKtmxqbPcVRFxaJUEtkAWkb8sDymOjJ3ghsDELVmxZLwBW
  31.506 +eD5P616m2FONTCPGvPwZympSj3y/C0WH/GmXETjk07pvM3OfPd+6S/E0d0uFFmd3
  31.507 +VDcE5e6eP2K5AQ0EWl09QgEIANK3/H034YHxnHCT/2yDtlXZriJzmDIWhGgrbOhT
  31.508 +kMZl+6Xgutpt5nIRd6otnpPTcgChcvHKFgIQJ1s8Nyg0wVztFgig/1vMwiPXrb28
  31.509 +wUapuKtKl213J0Rd9oHrs8GKLSj+iPC7QPVMguOETWmbbiBwRbYqgP+BhlL7FYyy
  31.510 +B3wEv4Ra1UBl9iEo0fb4j4irHw2dtT3L650EMFavr2EfH1AlTQCDlK0dqYAW7A7L
  31.511 +Md6I28Av2nf3macOBSOEHO7RZirqw9jt+2zU/mfADGWFBm3+uAINeMnFZmqups6e
  31.512 +YBqfk3/QSQSSqs1xf4EqnYt9/MfucxGPPvdhZXlnmESfjiEAEQEAAYkBPAQYAQgA
  31.513 +JhYhBCpeTdqGcjSFIILmeLxsGX3TyqCGBQJaXT1CAhsMBQkB4TOAAAoJELxsGX3T
  31.514 +yqCGe74H/iiYWaEc9/FO9E86Zo4vqEqpNS6emb8CzBc4jtx2CycXsVEPF1NVIMci
  31.515 +tVFiwET/P0Z6+N7gHTk/g55uwpzAOYSGL5K27VcO8xRUGzO81ckSfhLxqbx9O6ZC
  31.516 +C4sSN8xsNwg9XiJB/eEGIw/+rRxN6JgLkpIKp7kqwf08PWf751KGt3YK7GSvRj3s
  31.517 ++wPwXBxmWXq5LXwVoX+OJqa68YGj3aVpfeYWUEYwTLCmyUlxIGU6tV5YtpgwBbQj
  31.518 +HBp3g9aIP9N+tCkFLo7C0CFbwQeljv3bIfRyadrt4g2b2jUFKOh1muON9Ll3qBFa
  31.519 +0DLEZKCLp6Q+R1e3EHDh9hvt17USpOSZAQ0EWl09YQEIALUUb33D5Ix+7rCNooPt
  31.520 +6WHrSOPiwh9jtXauuEaKN85wsbRYDVVzYc6jqh88o6DqrC6EIdaCbyS3vsC7EBcC
  31.521 +ChsD+9yO+U6U09+zKhVRidoUWs0YjyqH5vmGJhpAgtG6uCZALnN8T0EIf6eJEgPQ
  31.522 +0EXKI2RNH5X59doU7muOCozFfEQu2YrBpN23ykx/xXouhWkMDuMi0nzueXXGclVE
  31.523 +zUQs6NGK0rTvBLgO7PNl1o14sswADOTcyWgl5kZv/Ci9kJMhKfTarqbCwqSHV7T+
  31.524 +unRrvoxoilHDFflQgFKmdS3hQKUvU0QUts05P8XwO8mciVYYbzQJA9tT23zwAaa8
  31.525 +RCkAEQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3Jv
  31.526 +dGhvZmYub3JnPokBVAQTAQgAPhYhBHQIXut3pl8GiQI2n6Iyjf2MyU9ABQJaXT1j
  31.527 +AhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEKIyjf2MyU9Au+0H
  31.528 +/RNGPMwHcL/Ao0ZuDjM7dRl0KvAC0gRgwCrjuwuEX9pajTqB3gWmT88jZx1cFdCO
  31.529 +3v49vKfPUAS34OMq+Y0A66l25vGxhPrGIgJf8J604FTT2BfFxs81mUNGvaRUUbE1
  31.530 +IM+66oB1fDR5oYYrvwFclC95MMuks5C0TRyT6jOqjoNFYR3Yj54BbMAXlZHwl997
  31.531 +yL1NeodcfN4CAbRD9m4dQPJx++HEM3cV9rRVibXjHSsG6wzU1YOi4/OCgVlSXm0R
  31.532 +cxnh76ZIgDZFeDwb+qI4gAvmZ4034P5YHHD2Hw+Qahvtztmm07nJk4PFKxA4otvm
  31.533 +slyaViDVAt9PKXrufiG9rvS5AQ0EWl09YwEIALGtSiV+kfbq5UyF/Vs0GiSOKGCa
  31.534 +Vs4PfOi1PLLOZ2vU9jeUabq6vemvI0tb1CepKWv0DLtHvhnmAhGd1SP8RIm64rhq
  31.535 +MHXJ4rDlsnVNCKW2SvDSFjija0w8eDVYpu6tWPDfx3YDVjwg3Eo/5Vor+BeElLub
  31.536 +eMl1xZD9aAeo5K1Yb1hBVW7Tea7nEnncuzbgo0/8N2qpaP0vPUgaOwxgSDHWAjBz
  31.537 +9F2gwjKPy+EhxMdwUkG2QZWXUBD+mVFrqWgj3fKbbkR/+V56AhJmT9/fLhcEjnGS
  31.538 +OAN+Ak/iTYeGTOFVviZCAEeNG8OWm0+qjWeOPNtg2XhtiEAvPIEFeYCV31EAEQEA
  31.539 +AYkBPAQYAQgAJhYhBHQIXut3pl8GiQI2n6Iyjf2MyU9ABQJaXT1jAhsMBQkB4TOA
  31.540 +AAoJEKIyjf2MyU9AjaMH/3FTivnCuy89fr1oAAmm3ay3S5+i+aiEqevByqs5w2po
  31.541 +rvUFM5kc3U0m2CsxFgawqhhjJ0soryFGbfjpMzCiqwTj0iv+MS8x+Os8JKCLRitq
  31.542 +LDc/ACqUMK+Dh9uSEbhwRqQMuY+3eHVEvtsGdfffYZ1KV76E7VcZxmwxhXwMnnJg
  31.543 +qMGvs/QSIgEX2Ak5B83IoiLNDQ3eluu3u8wYFbXYeC+9L43zMKTua21Nnc43Jsyk
  31.544 +P5LZQZNThJr4KnPN/lpZohdJMPdesVYIYgKmSVNKwzxXzgwdAB77v1FT56XGov15
  31.545 +TqmGFJvzqs4l/udPwvkmzEZD6qSI3moTu7PFBLx63DmZAQ0EWl091AEIALBdf7x7
  31.546 +dCG1daje6hp+vPBD63LJHNGRJgxrHTtcJvp1tLYI8TThRIxDTzKSwAORSqGs6Au1
  31.547 +4KqXrPFtVjEbpmieYLADSMAbTYp8j/JIRkg9BsqqJenPDUlhveq16uNaOgSN5Jk5
  31.548 +s3YR49TVeqPOcDgZ2nshLCNuY7AEtGpDRUgBpRwDWFyt6etLkhjW4iOj6Fpa5SlE
  31.549 +RHNn+MU4iq+8wUWAKefA44NWN8V6hJcvq1EFq7xddL67e91tqy1dKsux+LxjOSHl
  31.550 +wEYpHQc5tspUx6TL6mqnjO13fBIgA7MqKQ8njLv9y2JuQB4ZWrOEqwyq1ay0/GDm
  31.551 +vhTCzDsY0CgdjCUAEQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5y
  31.552 +ZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBKvqYkJ6kXQeKoCft1k7e0Nr
  31.553 +bITrBQJaXT3XAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEFk7
  31.554 +e0NrbITr3D8H/RVYdg5oO4OnuvgTTFrDbvFI9HnO+WCWEXsnARJCVjVhcTrX0/xW
  31.555 +8h7SQJpJlXmxOnIa/Q1InA/Xu36IyaHntgT39UPY9XCV28O7NnGmWMh2w3jNRr++
  31.556 +wUgwCtlZn1oZ/aZlHfFTx0rxN0l2CB8VKeILCwDh+GopDu0+nP8zOnbvedyU2MUt
  31.557 +fX5rrNmGwpqctWFzos0tOdFX/IVKltm28aGGsIl/K6Br2A3Xi4fRFpiRXunvvUhz
  31.558 +PLsbRgssB6g73Ds0b9xA9imsHPsqV6YJvFa5yyyeMFcIVeTR+a3BYgDpwN4CbO/P
  31.559 +Vg428s9wgUKBjWiTcqmIt0LAwP38iLR0fsa5AQ0EWl091gEIAPcFCRq6O8wkyQ/Z
  31.560 +RxFSxmZDaJcIXPJ2xA/i4ptJw/P+z0sSqB/R5HrOgnsLR1UxC9LYFXL+wBFIxOfw
  31.561 +HUixbiZUMlpMvkEUPZkMCJSAfTpWbxkqjzgoCzAnzmJn6kNddVFUFE+OZ+sLGii8
  31.562 +CBgxtTs3kNuIuFTZHd6vEhKC3A34LZJyvZ2GGvJBRJY2lyOuooJVsvXs39rJNtlm
  31.563 +wHn2ldRGET/FgSYwGynMsqGjuSveT6mGjukr29O4wsGDL9QgyCQfc3sZKqGd7DlU
  31.564 +3xcSWuIOF0Vx9jEfWeSXvZlJIKARe4Sjlhqpcq/9ukoWQ6siyJXMGZ8W7QJGBGEF
  31.565 +C7aHyBsAEQEAAYkBPAQYAQgAJhYhBKvqYkJ6kXQeKoCft1k7e0NrbITrBQJaXT3W
  31.566 +AhsMBQkB4TOAAAoJEFk7e0NrbITr7BAH/1yGx7ByDOGaYD03ZoBThXw3jcdb7W+Y
  31.567 +Oo3Ms6p9wTMGfbCsAEqnrEze6whU41vodpUlhdVGhxD5FCiI0KRBvkvH1RtD9Ka6
  31.568 +NC1ecSih4WAVlUz7trW8c+lfkhJqoJIkFc2fZJGopH5ytPISopm1tZU55rVzYkKt
  31.569 +XBdLg//ce+MtuqXpbVRbkCxBvzIugVFsPOiE6RUUhU29zxNOEIJ+ZsUxKcACtSvD
  31.570 +rgFvG5gQvC/7HEvjaIYKa6l0XCuxh8vBg/NkBQJuLMrCXG68AUHvU8tA3cXCV4mg
  31.571 +9BdQ4f4aMi+VNKHPGgfKhZcPr0C/ItdT1OQA/ROJk67v8SepMcVrjmmZAQ0EWl09
  31.572 +5AEIAM5aBmfgRPQfzZtqNFkXrtRIFIL3dYy0ewrfVKkJt7t7GRJ0pvOYQxtMbywg
  31.573 +m+sNtEMfwVp+QwOcAUcB18qWFzVn5L9KjsptG5ad8ubkNqzw1bihGi4Osi6TxciJ
  31.574 +Lj75UXP2q9lRPMsTpwx/iMkUleWopt4M7VgcqPNtRIppQUwYbUhlOMYNEAG71p6Q
  31.575 +sa4y5SfDwbH/lyIKdnv3CUsO1n45Fpig3psF1hd1lCT4AYGfzQzzUwnypg3+BzUC
  31.576 +peOxMeAU2FABeb6Oij7CiqjnHJh7dFXunGffic7zvks824a/V+a0+zLlq9i1Gfaj
  31.577 +9r3zwPYmP3Ksd9GJZ6gaOceI5OEAEQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxw
  31.578 +ZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBAllN3DxhBSx
  31.579 +viFclZuTV/46XYOBBQJaXT3nAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4B
  31.580 +AheAAAoJEJuTV/46XYOBtyMH/1a469CQgelc27UYm1m2uq8RRpbPMt4vGADavGHQ
  31.581 +oOXUU372xrPJ3MvsG3eFWVF1UVMR553FC7trljSzJWB5ZTakj74OcpXLSeyxnSez
  31.582 +qjiOJF3JGc8VLBKQdVlsjWHOceH3nz+7ivUVGj0QwdV3DiVyTQyoiggkzWe78G94
  31.583 +QlWyMWRgUGlL5iLE4KYGTaD5bmqn+/HcDqlxEm102gIAKZANgpyoC7WYNvAwTMp7
  31.584 +NC1mUvOWzQaNOdlk7WvseU4COpDXWn9YNmejkJaMcBf3w+WNnuDFJPND8OwFDypw
  31.585 +SMcQkMjqDgrUnvtU+SXn9jNK4abqN5XttNOmKi400euXf4e5AQ0EWl095gEIAPQ8
  31.586 +s7EW5Pf92vbLt7n/JMTQwg9vnNTKfkjhZeTPHd2J9qLU6UYJvovozNXT0Ynop4NU
  31.587 +GS8QU08kqHF9LKK4/HifqyVbocxn0yym5S7pNe3jvVTPFXBeTrcBkpFOsWsFnvzm
  31.588 +t/cFk1PnFWMDxu0cD//qG+UeS1ktQnGZK/TnUhx4eSFcWU3qdavQU6/JCrW3zQ6Y
  31.589 +OkYFYZl2WhC6vX4yQ4VQPoxPNjm41e3YFUcmJI8Z/j7EOsoIbVToPqfC5wqfbq/S
  31.590 +k7Ibe3wUMNvGFQpvbLYrI5yE3j9+nV74IfT2uBlBAuhbW98I7XJ4BvCnkcg/qeT+
  31.591 +btD37u8mSQw9a05k0zkAEQEAAYkBPAQYAQgAJhYhBAllN3DxhBSxviFclZuTV/46
  31.592 +XYOBBQJaXT3mAhsMBQkB4TOAAAoJEJuTV/46XYOBgzIIAI6QLoLTUfCba6wcHDor
  31.593 +wy7Ohtt8iMxu1wL30wIntSr+zEYwuEO2zcpUQA+uro7PTiBj00bJejBG15ZPEbHV
  31.594 +PT0sYSKAJRmc79nFT6plCSqUsorETgMw/QSGf/elW0jmuVjsxTeKnpTqQZ2TjM1X
  31.595 +5Gii3fttakDLTR7FLo3iP5Gs1TMsphRUl/XwzgzwBCn7X5gKBJOFcAskaYGDPKVV
  31.596 +/ffxB+L3XdEgRQTdpzq4lyosM3CsbKd5dz3fVEDYcpaQljhOO5aJw7oXZgl+a86F
  31.597 +xWKMunN2cEFOJaeDJzlv9PIEdyB18V08s+zxXXFQjdNt/5r16/13bPU5ngqclMiR
  31.598 +b7eZAQ0EWl0+HAEIAPcMKxHq+qljF5i7ESBoATO08KpIDy3V2u+wZaC9EXDgCRV7
  31.599 +UcN4XcQz0DaNitJmYQB5eC3nPU1q+NvBoRZ2HTuMKyhfuVlMwxN1HQhMB3DE40Xh
  31.600 +J3za1OW9wBzuaZQI9rxTExL+z8q8Dswivzuh4aDAeegvA0kvlsH2jFqGGabdqZLc
  31.601 +kkGSEtKxSMbCyuzyJ3B9dc+YEH7l4UlxqJsTxSVSzOWjUgmoLuXpTLQjJzyEACgq
  31.602 +RA1xUuDe1PYgoMOMk9PHHvmAa16VIUoPztXOZFPC7KHznEt3atPiJbaLvaOrsKe4
  31.603 +KKXgFTFJ0RI0fkTpSQTy2BCcYV/b4+SStFh/E8sAEQEAAbQxcEVwIFRlc3QgUmVj
  31.604 +aXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYh
  31.605 +BHOuKKWD/+Tr1Ltis5FXmxJzBDLNBQJaXT4eAhsDBQkB4TOABQsJCAcCBhUICQoL
  31.606 +AgQWAgMBAh4BAheAAAoJEJFXmxJzBDLNtRIH/jEONwd02tYIyRooWAFunAjsaqFr
  31.607 +LxslagwDlyhVNtuKXnrOtsjPUKTjI0zhveBBURAgzcNgn47VLo7F2YeS8be7hJ9l
  31.608 +fcQLyZhVfOKZCm9dnT9WZM5zOrSAS+4V/BPR3wsdQ86ZQvfHbgNPKnB02k87y0wD
  31.609 +0UR/iyWt+yURH07ePaiMnz2ED25UM+YjbDPbp6x2MLThMzn0zCzIjW86xJm1D9oW
  31.610 +f8cIVBFKtQRweaHLFrVQZG7IDrl/E/luCpEKikTbHZdiimmHijsOoodQoviPlfon
  31.611 +8itdnO543RcNVCEz4W7WatQw6zQbY3VLien6YAChOqfupHuu1HhTWHvIFWO5AQ0E
  31.612 +Wl0+HgEIAMAiyTdm6ku9jeNkfeVlKawMzzviJ4eQuq7SltZQP/vPGcI8orxvvT/0
  31.613 +yF73Wx1yoP3AXeHbjTv1TnNqC/bRVfDcNShlyy6/aRi8Z1wv81PwtSlKLCq6ZJSv
  31.614 +G6MFt40Oi8XY/zHwEPxyeAKcYTwP0rGZ35G/KDDMG7sIh/ikCN5APJDxEoFGj++O
  31.615 +4h3kL0oAXzSJYGQx2J4vlmKwtM+tQ/EVrVOY3hN9Cc/ZxiQsNja6gISDHT3Ucg2+
  31.616 +HvqAuhTUuzYwujCP4Wt9OCzerHi4SudgN4G33EueTToy+A6tOC/7JH+15LnWbDfw
  31.617 +GJSmRufmoeyfs4uxpNM4s4KlZentAE8AEQEAAYkBPAQYAQgAJhYhBHOuKKWD/+Tr
  31.618 +1Ltis5FXmxJzBDLNBQJaXT4eAhsMBQkB4TOAAAoJEJFXmxJzBDLNxGQIAL0/xrCt
  31.619 +b/ehDWWMBTtOy7GlYEQwYVU5mS0zSjipUtr9kvoriFcOu78b5Vo+dPbMj0jbmEUR
  31.620 +hYbplQGZZInVChz/hXQ/QwnQaLaLBJHvJ0RBeOJFkHwX48ddRXg1c/JzGfbj39xx
  31.621 +/Fsh4wQgANl9P+3BH8kAeQdKg5Co/90FgICxTSJYJ1ugRmzSG9EOsGPGS62L6p8W
  31.622 +PxSTPGTZVsYeXoOPeFYETKDvch3jgVlFL2FjwslrGJemKspSg5Yrw5Amfng/0wvd
  31.623 +v0E3HP0yp9cqyhenGu4O16kzl/vHtm1Kv9fBBK8kMhhq52HqHU6hzScWriDPuBf4
  31.624 +heoPkbiX4lLaVqSZAQ0EWl0/BQEIAMT3qCU5JYO2v+B4djovl4D3bb4gE9CUc4MV
  31.625 +LfRin6AZnPcPXcl41y+jtCOXgbG1MhVRGPZMiqaVtA6CP5r4/lAwV2wJ+vw7cJVW
  31.626 +oc1e0JANZsuZW9dY916SCKtiUd+ZkEfkPjcvWl2iLQ6FHTogTebxf1OuIbkqw8el
  31.627 +Z1CG51mb1qTReqeyElfSjBF9Q0nG0kjtyCzNzC0TpVZLMV9t7yCCWvosNHZKck3j
  31.628 +1WUFGPTHAyHht/wpjwIaSTcdlkrGTXiSbp70VcIUSFeA2ueP0Sc7Eq+JZ8XBWiaH
  31.629 +L34YI8WlK4SmiTPAoOAyAmhU4KVaivtfvUpVGSbGQG/8RLCWSjcAEQEAAbQxcEVw
  31.630 +IFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokB
  31.631 +VAQTAQgAPhYhBG4QYWJa2PRg2CmFeQ20ZpZD8/GnBQJaXT8IAhsDBQkB4TOABQsJ
  31.632 +CAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEA20ZpZD8/GniUMIAJyPOVIPG9MFxsvj
  31.633 +h7hhRUKj/zUABH3+SX9gLK5m0QC1lwdVK1FCuYOWIzeHZ+AnlCBOLq1Wg61aVSr5
  31.634 +oTk1h6sbizWe1cuyC4F4XnltzhOoD6RYmgehLeZV4U76nRIV3F6icFgY/L2Zn2s9
  31.635 +a+XtdUUGhF91xhM4UO4a1B4eu/wXH+ZhKLITNxC8Ru2RaFqIErPLNQZhSfAjtAf9
  31.636 +Tx6LTqWOxRscGSgri9YM6re57sTZ4bQto/Ny81ojSBcNuTUDC9w4/5IyOQQVz3Hx
  31.637 +6waU865H90gJ/p6VzbxnCJyE/73jL+YSM3eQYSAtqNoxHR6wFskBgSna1d2NNjkD
  31.638 +A22gRhe5AQ0EWl0/BwEIAOSCc032sIy2qicM3wx9IPu+Oq/wTQDm4afaLArI8UuQ
  31.639 +NSS0FEk8f5DW5CpcI33KNrt7ja2ph6eKeg8T7HD28I76xcNPSYLdAKpwpSsOIdWm
  31.640 +9tz9tVZmrsXZMeian08qxmgPIoPD430zuCLID5coB4L3Wyb9SKxNWcZuM/a9e25/
  31.641 +lf/HKsmXAxS1lxGyzN6Y7X+0b+zlvuKH2tPyJ1zxtG+x4yNLc730nKQ+4WIRDAUC
  31.642 +vfDdxktUHbqPdJYu3ZYJWysUjvHpGOg1cK6lavsumYzzt3VTfty5iCc5z7cpCvxn
  31.643 +SC77IhygBSGD73U0kk1hyDCjH6n2BPjDgAi5ppyECc8AEQEAAYkBPAQYAQgAJhYh
  31.644 +BG4QYWJa2PRg2CmFeQ20ZpZD8/GnBQJaXT8HAhsMBQkB4TOAAAoJEA20ZpZD8/Gn
  31.645 +0fgIAJF3UOFyHql4qU7nQzgRk05thYAtdS4nqp60tH4JFZOCAKvAG/4DznN3zhOE
  31.646 +vKdA804swa32V6tq6EHt2SdByO6Mx+gR92Dle2mJ5n+LHaZUOkVcwr+iKpqemrDZ
  31.647 +2wvfzATnj1wTUAOKgStjh6M1shzxSBQlhi1JrXuzr247BfrDatUoFwJJN5nvttCT
  31.648 +5/CJ+0YmbJ8E/HEOO3ZfMLb6KDudd5nLqGhr+3awT8iHSWeJc5L+GLTfOFBnaukp
  31.649 +ViqE87bEPUpHqOxpkkMHjCjf8XNrbCGqhnva/vmVoQo31ypvyptDS6HoFc1F7JcF
  31.650 +ZTgzfSrMy1QG9Y9RPO2pXRvQg9WZAQ0EWl0/iQEIALzY8Rw/OENLadJpABrqg+H7
  31.651 ++8HDg6NLh5HcoADrp5he+WJ7scJ1AgSEvFq6/CRbmV6B1O6KIl+CRO17AIL/advm
  31.652 +z82GBwZaEDLVOK1udMAPMHQL/SAIhakmhZrj2cvgUM8DqkraXD9smilAhM7ABA35
  31.653 +lYXQzCuGVXM2bXGBEd3kHvEsTUQYgWpI21bjtUbCiIx4eIsJWoo9LgJh+9lrRZNZ
  31.654 +I8lE7GciKqoV3CfdIbcEOlEvYd2uBBvOoB2KjsmqOS5XvwV77xzNiSxrtkf7WF2K
  31.655 +q3t10Thtl/0grK5RgVj9GTaJKpTQGnS9pxytcj7XAsbq1JtZWJRVykntd/sjzdMA
  31.656 +EQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhv
  31.657 +ZmYub3JnPokBVAQTAQgAPhYhBAWxBI8Yj5OsTUNw3DMS//Xf//neBQJaXT+MAhsD
  31.658 +BQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEDMS//Xf//neweMIALrA
  31.659 ++cRNEtZcke/TQWgvIs8X5TUap5xp5msw5JoSV/xG7jB77RFRS4/GwXHTISclrEsC
  31.660 +vMWPPStZ8/JuHQ5RoSI6i9EbpDIMBeE2jXpX/cI0vJ6cut7R6dRQ/wg34huaR+/e
  31.661 +LQjdpoIiw63S6a/ERZs1RBbp14kQLBuGM7zfjaa0TXSnZZSFgSIqCF4GqMyBbIm9
  31.662 +TT5NTsda0IjrpZmCQ3FPVMYlFb9JPRvTWLH1zQPSiEliF+GAkTNc4jGQ11qU5bl7
  31.663 +CTrLW/WaQkpOtOZciO+guKvz45XUdmTuS4Gw9OcHoiK2fIG/o9tl5G8XhugOlxKa
  31.664 +eG3S0QKdJ1Gm2CNQ7ZO5AQ0EWl0/iwEIAMivUQ9kPE0Al7/4qipBRRjnc1cytd+s
  31.665 +6akEzlkjxn47NjnCixd3lS4wXsHiKh+P2O1+7eVSXgKlC2VLz54C16jr+08xvjjj
  31.666 +TBGcqv7HSKLBYuN1ZOJ9uQ8Tjoh12w83eWOU8BopW9PTb16gkf9pc2RJAUXMyh7x
  31.667 +daSXEffXEUbKVLam4N6kZbIc6aLhOxoGRIbBIL2yvyHxFItgnRJrg22oJOoYkRWo
  31.668 +nGga2YT0BtlSRj3Q5+E7/XGveFUCvtGg3xEvU5Xy9xbMxkSDmN6o5GtFOB3JZp62
  31.669 +8OYWNMbGDaCmqFNWBIoQMw7PZGlDyujQ3QLAXbzsWPtkCUzSoBeYp7MAEQEAAYkB
  31.670 +PAQYAQgAJhYhBAWxBI8Yj5OsTUNw3DMS//Xf//neBQJaXT+LAhsMBQkB4TOAAAoJ
  31.671 +EDMS//Xf//nePXIH/1K2dCX2ouVCK8ih8UcuSnT+PZ+lkIV1zCFFqsDLHW3cm0zW
  31.672 +kvwTyDl1AIE+XrbcjFFyDn+swP75FSaF8jPmSIgajvjAhx9gP8bMyYr5joKhHLCS
  31.673 +CWa8V8trkq0ykp0ULCItD7e1uLCeELoOpFLsjhPJ6gzbUT0Haxwh5/vVW8dKYSEK
  31.674 +vQ3GoBxFVNtJmkPpDTjS5HBMeI6hJp4C7rlOjecxgOKjlQvy8GkXIfTWvaWFogBL
  31.675 +ZnVRUz7Id1BFYO706WJcpYMApr8JH/ZncApAPrixnN+Q0o91Hd+IujaZRwETuvKi
  31.676 +sq/hP4/qpDcUrLNHwBoo/AMPH0B07pH+Gse5S4uZAQ0EWl1AugEIALjgB8p7KNoH
  31.677 ++qtHcYeywtNcz4qN5OwvY/l27UrCGwWZqLkj/zw0bqPnrHOwZwmJhEsULkLvwsZS
  31.678 +cMLiJBi68V7cAYsa508DVGTl+jJp7+jCTnAkUF/fP5ldm/fbmipd0WUbgiHOUvq3
  31.679 +TAtko1XXRzRwZrFKo2jcdzHbvCtg4k3fXc7VhLtC8+JaaDKmdqRPHLOlIvd4uYih
  31.680 +MMX/NK9W6mj41nVZLrloxsSwtpMEy2NTjCMx0N67lezQe/DNN7hPkq7JNB8vfPlK
  31.681 +iOGxsvxyVHDxJVsQukEedANOZSwF5g2+WwyzEWWpjBA1S1CGeuDq+xlAbwnjTw9f
  31.682 +hZzW8INg9/EAEQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAudGVzdC5yZWNp
  31.683 +cEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBATyFL+JlhoCwmg32sS0To4iS/F8
  31.684 +BQJaXUC8AhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheAAAoJEMS0To4i
  31.685 +S/F8uzsH/1Jy38gq9ucwIMoG/M9JwSzt/sbX0qz7cJV8/VDqY7og/9vJ0uvyeHSK
  31.686 +EjqLLwT+dDdrUxzhMJQV2tT9NHgVdUBD7IxJ8cLZBRTesT5GqxV6/kL5OQjbaGfT
  31.687 +TZWUSu8gwD4cG486UziWeVxYHISdUqlcFlM61y+7NsdNvPf7HMPXuq0LZxHhi4iT
  31.688 +TPTobZLvuhMy/pv431wEumTxeWlV8frVSN+2SouuwjfltYsEW/INdliRtxrSPjt+
  31.689 +IeX67kYkzh03EpmQaAGIrKWrcJInDBr4jjvTDmLpA0jmTof+ezYCedNU0lhu2da3
  31.690 +Kww9TWDIllydWljGHrX0TlIjZBJbTJO5AQ0EWl1AuwEIANnDWto7aCVtE5+Wj+Ya
  31.691 +BoS4FeRnZc1iwqBgxAG8HLY5QcPvJkMDVyxye/pqofBRMzUY5gmQO2i7CZEVgW4T
  31.692 +kP8t5BGKLNqZcST1EcT8wfogxCyQKQ8m9+SJq+KX2RhD6SPwn/mkHFOjT/b65on1
  31.693 +h5h0SRn5CdRElLhGKweh5/33S+ElJYECuyyGSYkFQLWJrASyLIcg5Pm7Vw9L6UCV
  31.694 +AUlylUA64aBFGCAW/copoeJ/pUi9vfp7gjBLE7EiGEloG4BWdSUQIw6qhY1E04QP
  31.695 +bECrWEKPyl1SIwiwI90DIi0cG88Awia8NNnRwaYNkhuAV72kw8m3bfJo+XpARJWh
  31.696 +M7cAEQEAAYkBPAQYAQgAJhYhBATyFL+JlhoCwmg32sS0To4iS/F8BQJaXUC7AhsM
  31.697 +BQkB4TOAAAoJEMS0To4iS/F8Aw8H+gNSR6fp8L6luScLE9dQqRCJ2TAamVYmAsg5
  31.698 +QSoqYgIxSoEm6ocWikmUlZbUnpc6Ab0lhSzFjxID1cNISMHx83WQ5s6xsPXcRGzc
  31.699 +aCOEqwCS92mhYLcNdXgw/mh13wtMzXgIdGIVrHLmCH5FQ5SGJYfJl+dHtQBDMbZR
  31.700 +Wt0eu7wu+G3uICsT37OwhgaDSWHt2D8eaQfDIHFjCIZwUg6QX/f2JOF8Lkiz2LgI
  31.701 +pm3jDLRfNkmJweuKSJxNsYRLzdrGlUhTArHEle0WpjRDCuVi/k0zeXEzHm4E1Vxu
  31.702 +WF9O/YjNdEWPWbl6uQ0HsxQjM92oNQqvjBtdNIZlvuY1gN881x+ZAQ0EWl1CWAEI
  31.703 +AMihMRaJQz+/1DCPhcuHjCw8UhseHo6EkvNnNe+Rx6B6o3o8mBC283vwNk7mhpiv
  31.704 +aiL0oZ1N0T6gb2qdFSszPbeLNl/fD/uVEMxsnEeSsZBEHQnsY3KuXyldNzw+SoVn
  31.705 +9FX4GKgIPO/68JAUQjWKelrZTjw/EbhuMPqoTIQTGAq7psB0BKw4l3vEa1hH30H/
  31.706 +IuwDK07k8/JCKyxu2KKGdm71G1fdnKF+zJiOPqIuI0xC9vQoep3Wmk7L3NCD+6Qh
  31.707 +9qz4PlES6pPrY/3RDKwW00Hdoi5B3y2cXhto81umEIK36El/5mOKPPj7qtXX2JYr
  31.708 +MAXZqKS9dDy/1oPMAXhoYs8AEQEAAbQxcEVwIFRlc3QgUmVjaXBpZW50IDxwZXAu
  31.709 +dGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBMIxpo4zV6IAFofX
  31.710 +bLS83+ngSbCZBQJaXUJbAhsDBQkB4TOABQsJCAcCBhUICQoLAgQWAgMBAh4BAheA
  31.711 +AAoJELS83+ngSbCZD7MH/1PNPhfcomPoc60Hgoy3hD+ssJh+CYWzgH8V9Bu+bR4d
  31.712 +6x5xtiLZ7pYCHJbDTG+aNxOLWR31cwJHs0ZQ8a48rqZn93pCSOsDk4QBAMaWFQxt
  31.713 +cIlbPHVlA/s4TEvHTVEa7D+8Q7ovNr0UZwFsUl1CCis586MKiZigc2RT0OhfF4Mh
  31.714 +QpYsMjpXVy+YEdwXGiTxtjM5RTEM2I3F2/sJJ5LevRvvTxQuclWRX6EOoPDsR2Cr
  31.715 +rfH/2tGbUixlWR0tjYilqQbXVgDjIwUlmZpf6tvzcdx3NIkDQ3IfMiUnft0k3ctF
  31.716 +9AwjpFZMhywCqipWJhdtbewFCX3olsG0kpX169dVF3e5AQ0EWl1CWgEIANKRDayB
  31.717 +YTrbaNhxtvp5WLXSDnDdec2qYQ8MbimEP2xyWeqLoSUvajV0CqFqi69X9Lss85dx
  31.718 +UJY2J1P+Q0/D6OJI1ak4CD2o8ZjBpA3tvHTZhOV6LrkhjC1cyflmzlvRY8zScQbo
  31.719 +cxasy5pRx2fZ4Sz9LWU2pIzw0k4c9TwrMJH/4HUVqPxsb9r37SNAwZLaLW1WLidl
  31.720 +7bUfn147m9x5BzS+18AggSlqFPS19YO1+nYj9gqdOuLqHgXobyGpVdXEixbaB8pH
  31.721 +oQ/SFdL90Pe7V9Sg7gKjwPcEjerxz1A3Qib8cVf2OIncnn7oRQacHDfsabYYPgw9
  31.722 +NKxgc/R+/jsYZW0AEQEAAYkBPAQYAQgAJhYhBMIxpo4zV6IAFofXbLS83+ngSbCZ
  31.723 +BQJaXUJaAhsMBQkB4TOAAAoJELS83+ngSbCZxzoIAL/YfkKbnNcOTtJF61VVmrc5
  31.724 +XbSbNiTkgrpO835yTM4UOo/NnqAtFtMcsZwb9Qxq0TfEyvpzpPFjePIyL1m6PLIG
  31.725 +ECshsI8bBHpbCobufVVwuanX0fDcCdJmaSGhZR/QQUgFMXUvuwOj42WmELpuhO8s
  31.726 +fStyI9izLCZpm3O4gavffxaANMDgQ6acVULNriCR5dreTpRY2cQb0/S3hr/wQOGl
  31.727 +EvVokGUwjr8Sm25qxJMXXFeewjINZwATYuRWuzosESAeA6HN0bUOYZ0y6kSxp0rP
  31.728 +WX93Xmdn+7kEmz0qjehY/4gNHdsFo1V7P5zF/Lfsvwls1nK1PniRBlstosP/W6mZ
  31.729 +AQ0EWl1DbgEIAPHlp58Y1N+IDWiwC/ujgm4z/EbugWScOydEM4fC8cloaXUFPqGW
  31.730 +8wqaSKNCRTdaIxNdnlZ+EMUi9bGIXJMxsYLT5itG9LdKXn3brUoP+/PrU1552PiS
  31.731 +IOepj/afuBVHw1hQWOv63g2zBuyt6Q4apxU3OrQQ8zKHPybZHrgqHWt4S+1+8vRl
  31.732 +yardsZvOTYGHNGuz6j98xPpWsHyH9qaJFJjqZ+uCFscuBD3sEiC7yZELuiCXL8kZ
  31.733 +Ntpe7RX4lbcpbZ2gr0jQopdfTpfF8BBX86RztQVTflDDJhK7qEKzL29jeGQu7d7h
  31.734 +F6Ph4BMjrm0Aap9jOnUKBBnamGq8idaZXXsAEQEAAbQxcEVwIFRlc3QgUmVjaXBp
  31.735 +ZW50IDxwZXAudGVzdC5yZWNpcEBrZ3JvdGhvZmYub3JnPokBVAQTAQgAPhYhBBYK
  31.736 +d4s4c7J+r/gMSPd53JBfLTgNBQJaXUNxAhsDBQkB4TOABQsJCAcCBhUICQoLAgQW
  31.737 +AgMBAh4BAheAAAoJEPd53JBfLTgNg8wIAMSaxPOuReeDIUX7seAv8LPGdsh720Ok
  31.738 +TT2gUR/ibIRtRApcsA1JMW0RJFBB0NgdJJPkpiNHogNXMhbvwHVtYJwRdGj3KW1l
  31.739 +qFhq8x4Wl0kmIHt71bsJBLup9sz14KL62pMYHQJsPzfcke61WtLn2F8jQ5hkNAiJ
  31.740 +O+bGhlsipLEFHjPYqZD6F+Jpcesv0/J9NKCjdsXrVbbpO11X7NuOKinVBB4PWwJY
  31.741 +x4+jmQgqFjAzh5eEjHexWg+5GmUEznBv2ATNtG0sJyt3bP+7cWFLGj+C6NiCWB8k
  31.742 +FYGP0vj3emLowaJ490I9eRLp/CoUGW5bV5TxToUVQTRnkeEuRlUMH8C5AQ0EWl1D
  31.743 +cAEIANrM3mtiOfcPM+/0HDCUnzRIyjVkdKzHmszdKzazqZuhNy9rq78EbmOUy8Pg
  31.744 +rc9Hay6/PNdqHrQW0ZsJxSGyOgVbKc2SDeNHRQCTAEwYGQpotN8NbNBJo206NsQQ
  31.745 +MW2ZknTyAQUi/0AImEZduw9CPRlrNDvlE6zTSyHBlFIEcISYNBLFx5zf/3ufxLqt
  31.746 +Q45QSfGBOzLtA7cWJrDkJfK2Gd/Ofvq7yCRRxgb4RWZP5zYDvrNZrvqJJR2Q8T0P
  31.747 +crjwApBI8b4RJrTDG8iIvbuQizZWNNabx/6ux19qR9KsDyt8TRBUiXyUL7BQQvUo
  31.748 +47chCWAFpAnGp7evuRgXeS86sXkAEQEAAYkBPAQYAQgAJhYhBBYKd4s4c7J+r/gM
  31.749 +SPd53JBfLTgNBQJaXUNwAhsMBQkB4TOAAAoJEPd53JBfLTgNgBsH/2K8kMoKNALx
  31.750 +aA7wAtbaFnvNfNMIoMpHi5HUZJusISGx4wGhZ9I58xJ+G+rZG2GMP84mWnsP6Xfp
  31.751 +7e93zpxOQ3HkYugguWGIuGDalaG0bqRZ+L/rB3za1CWPGYqGk2FD2LMOt1HeQO1A
  31.752 +X+PTkygu97NwMxVMmZMHj3ukaoIc76dSalbO2LqAk24KfMVgslUdm7xpcOtjJwow
  31.753 +1yCABJmxr0Sjs8Ss8IYDHJjG5TA9+U9YNda4zBx98oJOOFTaf7Gs6/rLc28MO0Gl
  31.754 +PIjauQSNFEXPgax6u0s2taGD1hRNqobIAASv/+jbXLvKu8sD9HRp884KROo1VOsk
  31.755 +0s7Mx9JupyQ=
  31.756 +=/o33
  31.757  -----END PGP PUBLIC KEY BLOCK-----
    32.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    32.2 +++ b/test/test_keys/pub/pep.test.alexander-0x26B54E4E_pub.asc	Thu Jan 18 00:46:19 2018 +0100
    32.3 @@ -0,0 +1,31 @@
    32.4 +-----BEGIN PGP PUBLIC KEY BLOCK-----
    32.5 +
    32.6 +mQENBFpfqMMBCACz5nJSa4CRwT9IaF9HVduwwhv7Ibwu/5xEviQDczmeUYxGS3K5
    32.7 +P22aKWKiGdu9zebCBPqozLTz7bk4yCbIxuUm4+TVyJx0ORgaPswmbp5WnKhnzGo8
    32.8 +7iKLHerXTQOsFyA0eyVkEokR4GmNlyc0KK3hO4M6q71A43bYf7J0uZdXfezMoYJG
    32.9 +lcJ8UxmOLfB6GrNjd2zD244Csa/tCqjNXp2EUI4DrJWByVN18pHAeT+MmrJYkMM4
   32.10 +lOeQjeFCkPnekn8afBJ3QTaEF7yi8qrWQ0VJQpT9MSe56f5KaCbYWhv27ZzDVGWm
   32.11 +OavXDWfNgCp45jPEypAcD3jcUUrmTonYELrZABEBAAG0QVBlcCBUZXN0IEFsZXhh
   32.12 +bmRlciAocEVwIFRlc3QgS2VwKSA8cGVwLnRlc3QuYWxleGFuZGVyQHBlcHRlc3Qu
   32.13 +Y2g+iQFOBBMBCAA4FiEEOtn2D66yJnXbhzoTYtaYEya1Tk4FAlpfqMMCGwMFCwkI
   32.14 +BwIGFQgJCgsCBBYCAwECHgECF4AACgkQYtaYEya1Tk6IEQgAi8lkb117YPo+yOQG
   32.15 +Hryu37bgHn+pfEVHctvV3iuacEwzkpXSyOKS5o6/0V2kuLiWTBXLIIjyQZ173LdO
   32.16 +iDv26RlaOfwWegaw/A3QxedO0j3h1MaSV/6KEm+Y3Ti8B7bvWR3Uct/5D4kkC6MT
   32.17 +NyhcvtnnQykzkg1HaSSh7mL7rUQI0RNWLQAEtsWvUNpdfZCaRwpp1Ivm830Bmg5P
   32.18 +UTC7lJHnrg9Tcd/YVVAShk/1Y3Hns20paq3cM1So5J6SmXdrm9sp/9lnBhK+/55N
   32.19 +3JgsRcjy6Q0ONoyVfJOV+UjugP0VWmEEncrjYRKqQ7pvCyx3gFDv8vRWtHndYR00
   32.20 +V2gys7kBDQRaX6jDAQgAzzSE1q5Y5bcSXP2qGSg4oeVPK5Uj2nb4DF3IDF6KGmWi
   32.21 +NBk/DWmh0v89LjvgPR5l7HcHaQr7Xz48FFe3e3kNbwSckTLip6fnGZhBCQ480hMj
   32.22 +ZjXICetpc6WRbj8UNsLGkKluN4wsuvtgZ5z+XDUrOwgKgwmK2KxBWh26yhCZqUYt
   32.23 +4+l6wYbfCvzXIlUReaL+kc1lEmp5nQKdzLOXKay2MO5kY4ZTQLh8vsGIS03AoG7H
   32.24 +D4QuY6AVaB9tZ08wwoBKRRxh2/+Za12GX1qVm4aWdQd91cyaNepHnLOyejb9nyen
   32.25 +fBWEFx171MxOQRocasZSoE0+DQ9HtlI6GeSov9CbhwARAQABiQE2BBgBCAAgFiEE
   32.26 +Otn2D66yJnXbhzoTYtaYEya1Tk4FAlpfqMMCGwwACgkQYtaYEya1Tk5RgggAo2ka
   32.27 +kClMpSC24XoBbkCCLd5UgMyb7AvqUOZgtdP+kyS1AuRHuur2OhpF87ByEeZs+ZxD
   32.28 +8Hr0sju372hNey4c9e/VFMZvru+315RCF+4I/Cv5iMq6YhBCoNlL39ijzto3kCZl
   32.29 +RXg/twBPmB07D/M4k2/FXZWjqiQaN8DjXlIzXK+cVggdq7PXiyxurFdLghCeBKc+
   32.30 +J8ZR6sshYPkpe7SmgGqqeRX2Dv+xU8i4mxXM4JAif9dOWpxoWqH49ReJOm1gWCHo
   32.31 +u7d7NS5qO6M413dqF8QWO1c71qt5OSpq+wen9Z45TOwJo8wxs0BgtRZViNqClyzh
   32.32 +bFlp9Jpk5HhTOxOe6A==
   32.33 +=TT+k
   32.34 +-----END PGP PUBLIC KEY BLOCK-----
    33.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    33.2 +++ b/test/test_keys/pub/pep.test.bella-0xAF516AAE_pub.asc	Thu Jan 18 00:46:19 2018 +0100
    33.3 @@ -0,0 +1,31 @@
    33.4 +-----BEGIN PGP PUBLIC KEY BLOCK-----
    33.5 +
    33.6 +mQENBFpfuwkBCADXNMGMEroRCUpZ3jRQ9o38NBbOlmXXQ7ZSSuXdbJU9xd+UOUsj
    33.7 +JLapYg56XbU7o17oAFfa9VZlX57OtHbdGuoUgiNS5QT/T4R6cSiPg92+riVygVop
    33.8 +ncERHsXq+7noyiSdv7peSfVygcn2Z6T63HkY/tGJJVPbfFDDUWn+qKDydpFkSiUx
    33.9 +2SDBhgDOstYMxOsDRlIEOWWYIBXKJe2tN9DSA7nDtnu1GapLNHtZRfib8E+wwK5e
   33.10 ++WijHElB/dvJdL5Zp/gT1jhtr8WxWdmbKaJQwX49VT0uU/IdWfwxfZKEjaPTKNU9
   33.11 +urrRDq+0Kgo/j9s+edYiN5cKBUkIoEFNE4LvABEBAAG0OVBlcCBUZXN0IEJlbGxh
   33.12 +IChQZXAgVGVzdCBLZXkpIDxwZXAudGVzdC5iZWxsYUBwZXB0ZXN0LmNoPokBTgQT
   33.13 +AQgAOBYhBFYxvxNXMmoCqkcO7rgV73+kUWquBQJaX7sJAhsDBQsJCAcCBhUICQoL
   33.14 +AgQWAgMBAh4BAheAAAoJELgV73+kUWquzNEH/1CB1zM18gXosslKF/Kxh0xFqnXK
   33.15 +vrc7W4pO/rYNW+qfArGp7p+fjiqc5amPWO7GINW5BPw4taoAirr6sXSYB9uWYxRX
   33.16 +L//euTcuAIyeA0Xvw9I9EL92HtAMe71PNcsPeQskTtfCUGH2B8OZ84+bTSgf6WcL
   33.17 +T9CSESHl84rA+mVXQneGTXbY7cJ8i6g8HedNbzz/wmAJoByYrei1lypPnWXawBbx
   33.18 +heDe45NmvL1AQS7psXTPHJTFFZWCbswfEtYobRFX9UJ9rNGp0tY0CmzW4qRwR38P
   33.19 +57XkgurgM7nOvlYDlVium+qv7ERwQ4wsn5cSuAun93vjY9TM9O4MIzzFKdO5AQ0E
   33.20 +Wl+7CQEIAOg2gQ1AF4l+/2GRwwzBRk845rzLbpp81Hlys7JQ0P/klE1zoXcSWnsB
   33.21 +AHV9Y0utIEGwIIxKB0TAi8CFlDsM/pAI7TPjIMtxndltA0JWsWtT9d0HtmyOCslk
   33.22 +4VvFCsN7UgCrklwPSnabzbNr9W/J0bpGK6sey+u0BEPAcbZPRndm8JLy+EkbbOaa
   33.23 +h97xKt1kvtcutvkPwof62bVB0i5+GuvX33b5jokBjk9eWdSeZSNZQjiOtArCdnLM
   33.24 +a5H/EbdG4Ge4b7ey//E4VKdjGcD8KfW4lA6N9XZbLfJNjjLWn0XUa7BVE8K+6RDW
   33.25 +Z0cmg4v2TC73YarNW7N+lTgwf86RHMUAEQEAAYkBNgQYAQgAIBYhBFYxvxNXMmoC
   33.26 +qkcO7rgV73+kUWquBQJaX7sJAhsMAAoJELgV73+kUWqughYIAIpK+sEeeRt5ZKCE
   33.27 +H7d02F4CXVOCRY/+hJXwVVBtE86j6xjUgUpC0tb45UmUfiBMfiIN/aU56tE+8tsl
   33.28 +419oWyUXhR/jX3hBHxxWQRrL7omqKM1pC/TYt2EH93g7el4Gmv1xUjSG/djdaF15
   33.29 +iLyNsBVMH7r5VtvAcOhhiEZQzAUXek0HT+oD+g1rt91CIG/IN9SBpd0c7JgIe5m+
   33.30 +W1rVYl4wD5JCLi371eRokrVr6pd4/tSF6KBoik9HOphNbGdx7O3P0SapmjXUGbq2
   33.31 +UmjsEF9ObP32NdCI6srekivexxn3FUUWEe/PK3uGh9vc8vHONWo268LdPnr7619N
   33.32 +E1SUzJU=
   33.33 +=Ns6S
   33.34 +-----END PGP PUBLIC KEY BLOCK-----
    34.1 --- /dev/null	Thu Jan 01 00:00:00 1970 +0000
    34.2 +++ b/test/userid_alias_test.cc	Thu Jan 18 00:46:19 2018 +0100
    34.3 @@ -0,0 +1,85 @@
    34.4 +// This file is under GNU General Public License 3.0
    34.5 +// see LICENSE.txt
    34.6 +
    34.7 +#include <iostream>
    34.8 +#include <iostream>
    34.9 +#include <fstream>
   34.10 +#include <string>
   34.11 +#include <cstring> // for strcmp()
   34.12 +#include <assert.h>
   34.13 +#include "pEpEngine.h"
   34.14 +#include "message_api.h"
   34.15 +#include "keymanagement.h"
   34.16 +#include "test_util.h"
   34.17 +
   34.18 +using namespace std;
   34.19 +
   34.20 +int main() {
   34.21 +    cout << "\n*** userid_alias_test ***\n\n";
   34.22 +
   34.23 +    PEP_SESSION session;
   34.24 +    
   34.25 +    cout << "calling init()\n";
   34.26 +    PEP_STATUS status = init(&session);
   34.27 +    assert(status == PEP_STATUS_OK);
   34.28 +    assert(session);
   34.29 +    cout << "init() completed.\n";
   34.30 +
   34.31 +    const string alice_pub_key = slurp("test_keys/pub/pep-test-alice-0x6FF00E97_pub.asc");
   34.32 +    const string alice_priv_key = slurp("test_keys/priv/pep-test-alice-0x6FF00E97_priv.asc");
   34.33 +    
   34.34 +    PEP_STATUS statuspub = import_key(session, alice_pub_key.c_str(), alice_pub_key.length(), NULL);
   34.35 +    PEP_STATUS statuspriv = import_key(session, alice_priv_key.c_str(), alice_priv_key.length(), NULL);
   34.36 +    assert(statuspub == PEP_STATUS_OK);
   34.37 +    assert(statuspriv == PEP_STATUS_OK);
   34.38 +
   34.39 +    pEp_identity* alice = new_identity("pep.test.alice@pep-project.org", "4ABE3AAF59AC32CFE4F86500A9411D176FF00E97", PEP_OWN_USERID, "Alice Test");
   34.40 +
   34.41 +    const char* alias1 = "TheBigCheese";
   34.42 +    const char* alias2 = "PEBKAC";
   34.43 +
   34.44 +    char* own_id = NULL;
   34.45 +    status = get_default_own_userid(session, &own_id);
   34.46 +    if (!own_id)
   34.47 +        own_id = strdup(PEP_OWN_USERID);
   34.48 +    
   34.49 +    cout << "First, set up an identity with PEP_OWN_USERID as user_id." << endl;
   34.50 +    status = myself(session, alice);
   34.51 +    assert(status == PEP_STATUS_OK);
   34.52 +    cout << "After myself, user_id is " << alice->user_id << endl;
   34.53 +    assert(strcmp(alice->user_id, own_id) == 0);
   34.54 +    
   34.55 +    cout << "Now set up an identity with " << alias1 << " as user_id." << endl;
   34.56 +    free(alice->user_id);
   34.57 +    
   34.58 +    alice->user_id = strdup(alias1);
   34.59 +    status = myself(session, alice);
   34.60 +    assert(status == PEP_STATUS_OK);
   34.61 +    cout << "After myself, user_id is " << alice->user_id << endl;
   34.62 +    assert(strcmp(alice->user_id, own_id) == 0);
   34.63 +
   34.64 +    cout << "Now set up an identity with " << alias2 << " as user_id." << endl;
   34.65 +    free(alice->user_id);
   34.66 +    
   34.67 +    alice->user_id = strdup(alias2);
   34.68 +    status = myself(session, alice);
   34.69 +    assert(status == PEP_STATUS_OK);
   34.70 +    cout << "After myself, user_id is " << alice->user_id << endl;
   34.71 +    assert(strcmp(alice->user_id, own_id) == 0);    
   34.72 +
   34.73 +    char* default_id = NULL;
   34.74 +    status = get_userid_alias_default(session, alias1, &default_id);
   34.75 +    assert(status == PEP_STATUS_OK);
   34.76 +    cout << "Default user_id for " << alias1 << " is " << default_id << endl;
   34.77 +    assert(strcmp(default_id, own_id) == 0);
   34.78 +    
   34.79 +    free(default_id);
   34.80 +    default_id = NULL;
   34.81 +    status = get_userid_alias_default(session, alias2, &default_id);
   34.82 +    assert(status == PEP_STATUS_OK);
   34.83 +    cout << "Default user_id for " << alias2 << " is " << default_id << endl;
   34.84 +    assert(strcmp(default_id, own_id) == 0);
   34.85 +    
   34.86 +    
   34.87 +    return 0;
   34.88 +}