crypto/x509/x509_vfy.c:276: error: MEMORY_LEAK
  memory dynamically allocated by call to `sk_X509_new_null()` at line 260, column 24 is not reachable after line 276, column 12.
Showing all 80 steps of the trace


crypto/x509/x509_vfy.c:238:1: start of procedure X509_verify_cert()
236.   }
237.   
238. > int X509_verify_cert(X509_STORE_CTX *ctx)
239.   {
240.       struct dane_st *dane = (struct dane_st *)ctx->dane;

crypto/x509/x509_vfy.c:240:5: 
238.   int X509_verify_cert(X509_STORE_CTX *ctx)
239.   {
240. >     struct dane_st *dane = (struct dane_st *)ctx->dane;
241.   
242.       if (ctx->cert == NULL) {

crypto/x509/x509_vfy.c:242:9: Taking false branch
240.       struct dane_st *dane = (struct dane_st *)ctx->dane;
241.   
242.       if (ctx->cert == NULL) {
               ^
243.           X509err(X509_F_X509_VERIFY_CERT, X509_R_NO_CERT_SET_FOR_US_TO_VERIFY);
244.           return -1;

crypto/x509/x509_vfy.c:247:9: Taking false branch
245.       }
246.   
247.       if (ctx->chain != NULL) {
               ^
248.           /*
249.            * This X509_STORE_CTX has already been used to verify a cert. We

crypto/x509/x509_vfy.c:260:10: 
258.        * the first entry is in place
259.        */
260. >     if (((ctx->chain = sk_X509_new_null()) == NULL) ||
261.           (!sk_X509_push(ctx->chain, ctx->cert))) {
262.           X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE);

include/openssl/x509.h:169:1: start of procedure sk_X509_new_null()
  167.   typedef struct x509_cinf_st X509_CINF;
  168.   
  169. > DEFINE_STACK_OF(X509)
  170.   
  171.   /* This is used for a table of trust checking functions */

crypto/stack/stack.c:144:1: start of procedure sk_new_null()
    142.   }
    143.   
    144. > _STACK *sk_new_null(void)
    145.   {
    146.       return sk_new((int (*)(const void *, const void *))0);

crypto/stack/stack.c:146:5: 
    144.   _STACK *sk_new_null(void)
    145.   {
    146. >     return sk_new((int (*)(const void *, const void *))0);
    147.   }
    148.   

crypto/stack/stack.c:149:1: start of procedure sk_new()
      147.   }
      148.   
      149. > _STACK *sk_new(int (*c) (const void *, const void *))
      150.   {
      151.       _STACK *ret;

crypto/stack/stack.c:153:9: 
      151.       _STACK *ret;
      152.   
      153. >     if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)
      154.           goto err;
      155.       if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)

crypto/mem.c:156:1: start of procedure CRYPTO_zalloc()
        154.   }
        155.   
        156. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
        157.   {
        158.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:158:5: 
        156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
        157.   {
        158. >     void *ret = CRYPTO_malloc(num, file, line);
        159.   
        160.       if (ret != NULL)

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
          117.   }
          118.   
          119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
          120.   {
          121.       void *ret = NULL;

crypto/mem.c:121:5: 
          119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
          120.   {
          121. >     void *ret = NULL;
          122.   
          123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
          121.       void *ret = NULL;
          122.   
          123.       if (num <= 0)
                         ^
          124.           return NULL;
          125.   

crypto/mem.c:126:5: 
          124.           return NULL;
          125.   
          126. >     allow_customize = 0;
          127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
          128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
          134.       }
          135.   #else
          136. >     (void)file;
          137.       (void)line;
          138.       ret = malloc(num);

crypto/mem.c:137:5: 
          135.   #else
          136.       (void)file;
          137. >     (void)line;
          138.       ret = malloc(num);
          139.   #endif

crypto/mem.c:138:5: 
          136.       (void)file;
          137.       (void)line;
          138. >     ret = malloc(num);
          139.   #endif
          140.   

crypto/mem.c:153:5: 
          151.   #endif
          152.   
          153. >     return ret;
          154.   }
          155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
          152.   
          153.       return ret;
          154. > }
          155.   
          156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:160:9: Taking true branch
        158.       void *ret = CRYPTO_malloc(num, file, line);
        159.   
        160.       if (ret != NULL)
                       ^
        161.           memset(ret, 0, num);
        162.       return ret;

crypto/mem.c:161:9: 
        159.   
        160.       if (ret != NULL)
        161. >         memset(ret, 0, num);
        162.       return ret;
        163.   }

crypto/mem.c:162:5: 
        160.       if (ret != NULL)
        161.           memset(ret, 0, num);
        162. >     return ret;
        163.   }
        164.   

crypto/mem.c:163:1: return from a call to CRYPTO_zalloc
        161.           memset(ret, 0, num);
        162.       return ret;
        163. > }
        164.   
        165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/stack/stack.c:153:9: Taking false branch
      151.       _STACK *ret;
      152.   
      153.       if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)
                     ^
      154.           goto err;
      155.       if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)

crypto/stack/stack.c:155:9: 
      153.       if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)
      154.           goto err;
      155. >     if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)
      156.           goto err;
      157.       ret->comp = c;

crypto/mem.c:156:1: start of procedure CRYPTO_zalloc()
        154.   }
        155.   
        156. > void *CRYPTO_zalloc(size_t num, const char *file, int line)
        157.   {
        158.       void *ret = CRYPTO_malloc(num, file, line);

crypto/mem.c:158:5: 
        156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)
        157.   {
        158. >     void *ret = CRYPTO_malloc(num, file, line);
        159.   
        160.       if (ret != NULL)

crypto/mem.c:119:1: start of procedure CRYPTO_malloc()
          117.   }
          118.   
          119. > void *CRYPTO_malloc(size_t num, const char *file, int line)
          120.   {
          121.       void *ret = NULL;

crypto/mem.c:121:5: 
          119.   void *CRYPTO_malloc(size_t num, const char *file, int line)
          120.   {
          121. >     void *ret = NULL;
          122.   
          123.       if (num <= 0)

crypto/mem.c:123:9: Taking false branch
          121.       void *ret = NULL;
          122.   
          123.       if (num <= 0)
                         ^
          124.           return NULL;
          125.   

crypto/mem.c:126:5: 
          124.           return NULL;
          125.   
          126. >     allow_customize = 0;
          127.   #ifndef OPENSSL_NO_CRYPTO_MDEBUG
          128.       if (call_malloc_debug) {

crypto/mem.c:136:5: 
          134.       }
          135.   #else
          136. >     (void)file;
          137.       (void)line;
          138.       ret = malloc(num);

crypto/mem.c:137:5: 
          135.   #else
          136.       (void)file;
          137. >     (void)line;
          138.       ret = malloc(num);
          139.   #endif

crypto/mem.c:138:5: 
          136.       (void)file;
          137.       (void)line;
          138. >     ret = malloc(num);
          139.   #endif
          140.   

crypto/mem.c:153:5: 
          151.   #endif
          152.   
          153. >     return ret;
          154.   }
          155.   

crypto/mem.c:154:1: return from a call to CRYPTO_malloc
          152.   
          153.       return ret;
          154. > }
          155.   
          156.   void *CRYPTO_zalloc(size_t num, const char *file, int line)

crypto/mem.c:160:9: Taking true branch
        158.       void *ret = CRYPTO_malloc(num, file, line);
        159.   
        160.       if (ret != NULL)
                       ^
        161.           memset(ret, 0, num);
        162.       return ret;

crypto/mem.c:161:9: 
        159.   
        160.       if (ret != NULL)
        161. >         memset(ret, 0, num);
        162.       return ret;
        163.   }

crypto/mem.c:162:5: 
        160.       if (ret != NULL)
        161.           memset(ret, 0, num);
        162. >     return ret;
        163.   }
        164.   

crypto/mem.c:163:1: return from a call to CRYPTO_zalloc
        161.           memset(ret, 0, num);
        162.       return ret;
        163. > }
        164.   
        165.   void *CRYPTO_realloc(void *str, size_t num, const char *file, int line)

crypto/stack/stack.c:155:9: Taking false branch
      153.       if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)
      154.           goto err;
      155.       if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)
                     ^
      156.           goto err;
      157.       ret->comp = c;

crypto/stack/stack.c:157:5: 
      155.       if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)
      156.           goto err;
      157. >     ret->comp = c;
      158.       ret->num_alloc = MIN_NODES;
      159.       return (ret);

crypto/stack/stack.c:158:5: 
      156.           goto err;
      157.       ret->comp = c;
      158. >     ret->num_alloc = MIN_NODES;
      159.       return (ret);
      160.   

crypto/stack/stack.c:159:5: 
      157.       ret->comp = c;
      158.       ret->num_alloc = MIN_NODES;
      159. >     return (ret);
      160.   
      161.    err:

crypto/stack/stack.c:164:1: return from a call to sk_new
      162.       OPENSSL_free(ret);
      163.       return (NULL);
      164. > }
      165.   
      166.   int sk_insert(_STACK *st, void *data, int loc)

crypto/stack/stack.c:147:1: return from a call to sk_new_null
    145.   {
    146.       return sk_new((int (*)(const void *, const void *))0);
    147. > }
    148.   
    149.   _STACK *sk_new(int (*c) (const void *, const void *))

include/openssl/x509.h:169:1: return from a call to sk_X509_new_null
  167.   typedef struct x509_cinf_st X509_CINF;
  168.   
  169. > DEFINE_STACK_OF(X509)
  170.   
  171.   /* This is used for a table of trust checking functions */

crypto/x509/x509_vfy.c:260:10: Taking false branch
258.        * the first entry is in place
259.        */
260.       if (((ctx->chain = sk_X509_new_null()) == NULL) ||
                ^
261.           (!sk_X509_push(ctx->chain, ctx->cert))) {
262.           X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE);

crypto/x509/x509_vfy.c:261:11: 
259.        */
260.       if (((ctx->chain = sk_X509_new_null()) == NULL) ||
261. >         (!sk_X509_push(ctx->chain, ctx->cert))) {
262.           X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE);
263.           return -1;

include/openssl/x509.h:169:1: start of procedure sk_X509_push()
  167.   typedef struct x509_cinf_st X509_CINF;
  168.   
  169. > DEFINE_STACK_OF(X509)
  170.   
  171.   /* This is used for a table of trust checking functions */

crypto/stack/stack.c:258:1: start of procedure sk_push()
    256.   }
    257.   
    258. > int sk_push(_STACK *st, void *data)
    259.   {
    260.       return (sk_insert(st, data, st->num));

crypto/stack/stack.c:260:5: 
    258.   int sk_push(_STACK *st, void *data)
    259.   {
    260. >     return (sk_insert(st, data, st->num));
    261.   }
    262.   

crypto/stack/stack.c:166:1: start of procedure sk_insert()
      164.   }
      165.   
      166. > int sk_insert(_STACK *st, void *data, int loc)
      167.   {
      168.       char **s;

crypto/stack/stack.c:170:9: Taking false branch
      168.       char **s;
      169.   
      170.       if (st == NULL)
                     ^
      171.           return 0;
      172.       if (st->num_alloc <= st->num + 1) {

crypto/stack/stack.c:172:9: Taking false branch
      170.       if (st == NULL)
      171.           return 0;
      172.       if (st->num_alloc <= st->num + 1) {
                     ^
      173.           s = OPENSSL_realloc((char *)st->data,
      174.                               (unsigned int)sizeof(char *) * st->num_alloc * 2);

crypto/stack/stack.c:180:10: Taking true branch
      178.           st->num_alloc *= 2;
      179.       }
      180.       if ((loc >= (int)st->num) || (loc < 0))
                      ^
      181.           st->data[st->num] = data;
      182.       else {

crypto/stack/stack.c:181:9: 
      179.       }
      180.       if ((loc >= (int)st->num) || (loc < 0))
      181. >         st->data[st->num] = data;
      182.       else {
      183.           memmove(&(st->data[loc + 1]),

crypto/stack/stack.c:187:5: 
      185.           st->data[loc] = data;
      186.       }
      187. >     st->num++;
      188.       st->sorted = 0;
      189.       return (st->num);

crypto/stack/stack.c:188:5: 
      186.       }
      187.       st->num++;
      188. >     st->sorted = 0;
      189.       return (st->num);
      190.   }

crypto/stack/stack.c:189:5: 
      187.       st->num++;
      188.       st->sorted = 0;
      189. >     return (st->num);
      190.   }
      191.   

crypto/stack/stack.c:190:1: return from a call to sk_insert
      188.       st->sorted = 0;
      189.       return (st->num);
      190. > }
      191.   
      192.   void *sk_delete_ptr(_STACK *st, void *p)

crypto/stack/stack.c:261:1: return from a call to sk_push
    259.   {
    260.       return (sk_insert(st, data, st->num));
    261. > }
    262.   
    263.   int sk_unshift(_STACK *st, void *data)

include/openssl/x509.h:169:1: return from a call to sk_X509_push
  167.   typedef struct x509_cinf_st X509_CINF;
  168.   
  169. > DEFINE_STACK_OF(X509)
  170.   
  171.   /* This is used for a table of trust checking functions */

crypto/x509/x509_vfy.c:261:11: Taking false branch
259.        */
260.       if (((ctx->chain = sk_X509_new_null()) == NULL) ||
261.           (!sk_X509_push(ctx->chain, ctx->cert))) {
                 ^
262.           X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE);
263.           return -1;

crypto/x509/x509_vfy.c:265:5: 
263.           return -1;
264.       }
265. >     X509_up_ref(ctx->cert);
266.       ctx->num_untrusted = 1;
267.   

crypto/x509/x509_set.c:149:1: start of procedure X509_up_ref()
  147.   }
  148.   
  149. > void X509_up_ref(X509 *x)
  150.   {
  151.       CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);

crypto/x509/x509_set.c:151:5: 
  149.   void X509_up_ref(X509 *x)
  150.   {
  151. >     CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
  152.   }
  153.   

crypto/lock.c:455:1: start of procedure CRYPTO_add_lock()
    453.   }
    454.   
    455. > int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,
    456.                       int line)
    457.   {

crypto/lock.c:458:5: 
    456.                       int line)
    457.   {
    458. >     int ret = 0;
    459.   
    460.       if (add_lock_callback != NULL) {

crypto/lock.c:460:9: Taking true branch
    458.       int ret = 0;
    459.   
    460.       if (add_lock_callback != NULL) {
                   ^
    461.   #ifdef LOCK_DEBUG
    462.           int before = *pointer;

crypto/lock.c:465:9: Skipping __function_pointer__(): unresolved function pointer
    463.   #endif
    464.   
    465.           ret = add_lock_callback(pointer, amount, type, file, line);
                   ^
    466.   #ifdef LOCK_DEBUG
    467.           {

crypto/lock.c:492:5: 
    490.           CRYPTO_lock(CRYPTO_UNLOCK | CRYPTO_WRITE, type, file, line);
    491.       }
    492. >     return (ret);
    493.   }
    494.   

crypto/lock.c:493:1: return from a call to CRYPTO_add_lock
    491.       }
    492.       return (ret);
    493. > }
    494.   
    495.   const char *CRYPTO_get_lock_name(int type)

crypto/x509/x509_set.c:152:1: return from a call to X509_up_ref
  150.   {
  151.       CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);
  152. > }
  153.   
  154.   long X509_get_version(X509 *x)

crypto/x509/x509_vfy.c:266:5: 
264.       }
265.       X509_up_ref(ctx->cert);
266. >     ctx->num_untrusted = 1;
267.   
268.       /*

crypto/x509/x509_vfy.c:274:9: Taking true branch
272.        * the verify callback, or not set SSL_VERIFY_PEER.
273.        */
274.       if (DANETLS_ENABLED(dane))
               ^
275.           return dane_verify(ctx);
276.       return verify_chain(ctx);

crypto/x509/x509_vfy.c:274:9: Taking false branch
272.        * the verify callback, or not set SSL_VERIFY_PEER.
273.        */
274.       if (DANETLS_ENABLED(dane))
               ^
275.           return dane_verify(ctx);
276.       return verify_chain(ctx);

crypto/x509/x509_vfy.c:276:5: Skipping verify_chain(): empty list of specs
274.       if (DANETLS_ENABLED(dane))
275.           return dane_verify(ctx);
276.       return verify_chain(ctx);
           ^
277.   }
278.   

int X509_verify_cert(X509_STORE_CTX *ctx)
{
    struct dane_st *dane = (struct dane_st *)ctx->dane;
    if (ctx->cert == NULL) {
        X509err(X509_F_X509_VERIFY_CERT, X509_R_NO_CERT_SET_FOR_US_TO_VERIFY);
        return -1;
    }
    if (ctx->chain != NULL) {
        X509err(X509_F_X509_VERIFY_CERT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
        return -1;
    }
    if (((ctx->chain = sk_X509_new_null()) == NULL) ||
        (!sk_X509_push(ctx->chain, ctx->cert))) {
        X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE);
        return -1;
    }
    X509_up_ref(ctx->cert);
    ctx->num_untrusted = 1;
    if (DANETLS_ENABLED(dane))
        return dane_verify(ctx);
    return verify_chain(ctx);
}
['int X509_verify_cert(X509_STORE_CTX *ctx)\n{\n    struct dane_st *dane = (struct dane_st *)ctx->dane;\n    if (ctx->cert == NULL) {\n        X509err(X509_F_X509_VERIFY_CERT, X509_R_NO_CERT_SET_FOR_US_TO_VERIFY);\n        return -1;\n    }\n    if (ctx->chain != NULL) {\n        X509err(X509_F_X509_VERIFY_CERT, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);\n        return -1;\n    }\n    if (((ctx->chain = sk_X509_new_null()) == NULL) ||\n        (!sk_X509_push(ctx->chain, ctx->cert))) {\n        X509err(X509_F_X509_VERIFY_CERT, ERR_R_MALLOC_FAILURE);\n        return -1;\n    }\n    X509_up_ref(ctx->cert);\n    ctx->num_untrusted = 1;\n    if (DANETLS_ENABLED(dane))\n        return dane_verify(ctx);\n    return verify_chain(ctx);\n}', 'DEFINE_STACK_OF(X509)', '_STACK *sk_new_null(void)\n{\n    return sk_new((int (*)(const void *, const void *))0);\n}', '_STACK *sk_new(int (*c) (const void *, const void *))\n{\n    _STACK *ret;\n    if ((ret = OPENSSL_zalloc(sizeof(_STACK))) == NULL)\n        goto err;\n    if ((ret->data = OPENSSL_zalloc(sizeof(*ret->data) * MIN_NODES)) == NULL)\n        goto err;\n    ret->comp = c;\n    ret->num_alloc = MIN_NODES;\n    return (ret);\n err:\n    OPENSSL_free(ret);\n    return (NULL);\n}', 'void *CRYPTO_zalloc(size_t num, const char *file, int line)\n{\n    void *ret = CRYPTO_malloc(num, file, line);\n    if (ret != NULL)\n        memset(ret, 0, num);\n    return ret;\n}', 'void *CRYPTO_malloc(size_t num, const char *file, int line)\n{\n    void *ret = NULL;\n    if (num <= 0)\n        return NULL;\n    allow_customize = 0;\n#ifndef OPENSSL_NO_CRYPTO_MDEBUG\n    if (call_malloc_debug) {\n        CRYPTO_mem_debug_malloc(NULL, num, 0, file, line);\n        ret = malloc(num);\n        CRYPTO_mem_debug_malloc(ret, num, 1, file, line);\n    } else {\n        ret = malloc(num);\n    }\n#else\n    (void)file;\n    (void)line;\n    ret = malloc(num);\n#endif\n#ifndef OPENSSL_CPUID_OBJ\n    if (ret && (num > 2048)) {\n        extern unsigned char cleanse_ctr;\n        ((unsigned char *)ret)[0] = cleanse_ctr;\n    }\n#endif\n    return ret;\n}', 'int sk_push(_STACK *st, void *data)\n{\n    return (sk_insert(st, data, st->num));\n}', 'int sk_insert(_STACK *st, void *data, int loc)\n{\n    char **s;\n    if (st == NULL)\n        return 0;\n    if (st->num_alloc <= st->num + 1) {\n        s = OPENSSL_realloc((char *)st->data,\n                            (unsigned int)sizeof(char *) * st->num_alloc * 2);\n        if (s == NULL)\n            return (0);\n        st->data = s;\n        st->num_alloc *= 2;\n    }\n    if ((loc >= (int)st->num) || (loc < 0))\n        st->data[st->num] = data;\n    else {\n        memmove(&(st->data[loc + 1]),\n                &(st->data[loc]), sizeof(char *) * (st->num - loc));\n        st->data[loc] = data;\n    }\n    st->num++;\n    st->sorted = 0;\n    return (st->num);\n}', 'void X509_up_ref(X509 *x)\n{\n    CRYPTO_add(&x->references, 1, CRYPTO_LOCK_X509);\n}', 'int CRYPTO_add_lock(int *pointer, int amount, int type, const char *file,\n                    int line)\n{\n    int ret = 0;\n    if (add_lock_callback != NULL) {\n#ifdef LOCK_DEBUG\n        int before = *pointer;\n#endif\n        ret = add_lock_callback(pointer, amount, type, file, line);\n#ifdef LOCK_DEBUG\n        {\n            CRYPTO_THREADID id;\n            CRYPTO_THREADID_current(&id);\n            fprintf(stderr, "ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\\n",\n                    CRYPTO_THREADID_hash(&id), before, amount, ret,\n                    CRYPTO_get_lock_name(type), file, line);\n        }\n#endif\n    } else {\n        CRYPTO_lock(CRYPTO_LOCK | CRYPTO_WRITE, type, file, line);\n        ret = *pointer + amount;\n#ifdef LOCK_DEBUG\n        {\n            CRYPTO_THREADID id;\n            CRYPTO_THREADID_current(&id);\n            fprintf(stderr, "ladd:%08lx:%2d+%2d->%2d %-18s %s:%d\\n",\n                    CRYPTO_THREADID_hash(&id),\n                    *pointer, amount, ret,\n                    CRYPTO_get_lock_name(type), file, line);\n        }\n#endif\n        *pointer = ret;\n        CRYPTO_lock(CRYPTO_UNLOCK | CRYPTO_WRITE, type, file, line);\n    }\n    return (ret);\n}']