{
  "trx_id": "30393fcf73522b35f19cb3ab774b7afb38812f77",
  "block": 106142364,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2026-05-17T23:20:48",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "6142.847206 VESTS"
    }
  ]
}

{
  "trx_id": "502e423decb2a60a6152d6d48f5c10b49463637b",
  "block": 105971330,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2026-05-12T00:10:54",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "3430.636801 VESTS"
    }
  ]
}

{
  "trx_id": "d7702e285744e30ae4dac0b46b585d3f88104314",
  "block": 105510045,
  "trx_in_block": 3,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2026-04-25T22:43:15",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "6155.362962 VESTS"
    }
  ]
}

{
  "trx_id": "f8e181b4201beda3fad4418a266314ea5be9e8fa",
  "block": 99251533,
  "trx_in_block": 5,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2025-09-19T23:59:54",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "3521.612370 VESTS"
    }
  ]
}

{
  "trx_id": "bd1d1590d7f316b91a46db83065d2907059eb1ef",
  "block": 96637745,
  "trx_in_block": 2,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2025-06-21T00:34:00",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "15678.380276 VESTS"
    }
  ]
}

{
  "trx_id": "1bf9fdc643e7ac9e284cd3b6b5061ddc6d1a5396",
  "block": 96635381,
  "trx_in_block": 9,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2025-06-20T22:35:27",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "c",
      "author": "debuglove",
      "permlink": "join-me-at-udemy-for-free",
      "title": "Join me at Udemy for Free",
      "body": "@@ -198,8 +198,131 @@\n onogame/\n+%0A%0A!%5BFactory Course.png%5D(https://cdn.steemitimages.com/DQmXmwAFXAdiJ3B8ZCvejXor2XAbxY9NcBG577wt3s1TANb/Factory%2520Course.png)\n",
      "json_metadata": "{\"tags\":[\"monogame\",\"factory\"],\"links\":[\"https://www.udemy.com/course/creating-objects-smartly-factory-pattern-with-c-monogame/\"],\"app\":\"steemit/0.2\",\"format\":\"markdown\",\"image\":[\"https://cdn.steemitimages.com/DQmXmwAFXAdiJ3B8ZCvejXor2XAbxY9NcBG577wt3s1TANb/Factory%20Course.png\"]}"
    }
  ]
}

{
  "trx_id": "31bdcad0ae9e7bfee20d266401f69cdc4bf12fec",
  "block": 96635362,
  "trx_in_block": 4,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2025-06-20T22:34:30",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "c",
      "author": "debuglove",
      "permlink": "join-me-at-udemy-for-free",
      "title": "Join me at Udemy for Free",
      "body": "Join me at my new free course on udemy: Creating Objects Smartly: Factory Pattern with C# & MonoGame. See you there!\n\n\nhttps://www.udemy.com/course/creating-objects-smartly-factory-pattern-with-c-monogame/",
      "json_metadata": "{\"tags\":[\"c\",\"monogame\",\"factory\"],\"links\":[\"https://www.udemy.com/course/creating-objects-smartly-factory-pattern-with-c-monogame/\"],\"app\":\"steemit/0.2\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "e772fb749734ffc00d426bec9f79165256d7b1a2",
  "block": 91295319,
  "trx_in_block": 1,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2024-12-17T00:42:00",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "3636.402817 VESTS"
    }
  ]
}

{
  "trx_id": "49b9d06f0c6a33d1bcb7fb9fec8e65506bd28892",
  "block": 79849543,
  "trx_in_block": 1,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2023-11-13T16:25:24",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "3805.536349 VESTS"
    }
  ]
}

{
  "trx_id": "cfd58146694fa3343db527966ef527ee91c72bc4",
  "block": 78346554,
  "trx_in_block": 2,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2023-09-21T20:45:48",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "6742.815135 VESTS"
    }
  ]
}

{
  "trx_id": "4d7b11348e56223deedebebdf713c59014519ff8",
  "block": 70162099,
  "trx_in_block": 3,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2022-12-10T02:23:21",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "debuglove",
      "permlink": "python-finding-the-largest-or-smallest-itens-in-a-collection",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "6bf21d85a28ffea52a4ad73808b07832e3598723",
  "block": 69112058,
  "trx_in_block": 8,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2022-11-03T10:41:45",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "6964.496573 VESTS"
    }
  ]
}

{
  "trx_id": "dc91836d69f50bf3d4eac96af569b75a0ab8bffd",
  "block": 59246655,
  "trx_in_block": 27,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2021-11-23T13:13:33",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "7229.044573 VESTS"
    }
  ]
}

{
  "trx_id": "57aea57def39e8ba5af9aab67f8e7d14706af661",
  "block": 58377614,
  "trx_in_block": 8,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2021-10-24T03:01:21",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "26762.352448 VESTS"
    }
  ]
}

{
  "trx_id": "f00eaf82f911453abec3419ab8dc6ef892c5d953",
  "block": 56674405,
  "trx_in_block": 7,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2021-08-25T13:50:45",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "debuglove",
      "permlink": "python-finding-the-largest-or-smallest-itens-in-a-collection",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "4b860c5269cd21d65998b5dd80d4988b8daf1b59",
  "block": 56644726,
  "trx_in_block": 17,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2021-08-24T12:57:42",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "debuglove",
      "permlink": "explicando-a-funcao-chmod-perl",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "90170248501d9e3c52ee7939f5fb5c1f6b9d756b",
  "block": 56636406,
  "trx_in_block": 1,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2021-08-24T05:58:42",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "chmod-perl",
      "author": "debuglove",
      "permlink": "explicando-a-funcao-chmod-perl",
      "title": "Explicando a função CHMOD - Perl",
      "body": "https://youtu.be/5v5vHqp5m5A",
      "json_metadata": "{\"tags\":[\"chmod-perl\"],\"image\":[\"https://img.youtube.com/vi/5v5vHqp5m5A/0.jpg\"],\"links\":[\"https://youtu.be/5v5vHqp5m5A\"],\"app\":\"steemit/0.2\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "f3ca07e553521288db91a42348b7c33158a1b57b",
  "block": 56261116,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2021-08-11T03:16:36",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "26947.646184 VESTS"
    }
  ]
}

{
  "trx_id": "90daac0320ddd81e36609191d20e6f9068702e5f",
  "block": 56261028,
  "trx_in_block": 2,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2021-08-11T03:12:12",
  "op": [
    "transfer",
    {
      "from": "executive-board",
      "to": "debuglove",
      "amount": "0.001 STEEM",
      "memo": "❗ Hello debuglove, great that you are using the STEEM blockchain. The Executive Board is publishing insider infos at https://discord.gg/KyBbmhh on how you will be earning the most coins. It's easy, just follow the instructions. THE 1000X BOOSTER KEY is already waiting for you over there too. 😉 Warm regards, The Executive Board."
    }
  ]
}

{
  "trx_id": "c04b4847f7925aaccde9ac7c3a11e644779d80ce",
  "block": 56260979,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2021-08-11T03:09:45",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "python",
      "author": "debuglove",
      "permlink": "python-finding-the-largest-or-smallest-itens-in-a-collection",
      "title": "Python - Finding The Largest or Smallest itens in a collection",
      "body": "https://www.youtube.com/watch?v=uegDxATykGs&t=1s",
      "json_metadata": "{\"tags\":[\"python\",\"collections\"],\"image\":[\"https://img.youtube.com/vi/uegDxATykGs/0.jpg\"],\"links\":[\"https://www.youtube.com/watch?v=uegDxATykGs&t=1s\"],\"app\":\"steemit/0.2\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "f53d22551fa6e8566802be4c061a8332b656ac1b",
  "block": 54606758,
  "trx_in_block": 15,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2021-06-14T00:00:06",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "7368.798462 VESTS"
    }
  ]
}

{
  "trx_id": "10964a4260887da063282014455bf97475b3184d",
  "block": 49354255,
  "trx_in_block": 3,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-12-11T10:20:27",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "7556.220436 VESTS"
    }
  ]
}

{
  "trx_id": "f4aadf2c7a0d40bead5531f2503dfc542d57d93b",
  "block": 49205816,
  "trx_in_block": 2,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-12-06T03:57:30",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "1912.543513 VESTS"
    }
  ]
}

{
  "trx_id": "8cdb15e0061af1d4e7a8f212d09c7b882981724e",
  "block": 49186927,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-12-05T11:54:51",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "7562.587075 VESTS"
    }
  ]
}

{
  "trx_id": "c025071d589592a4d70c2ca2c82ab802f35f9ac1",
  "block": 48255818,
  "trx_in_block": 6,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-11-02T13:57:06",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "1920.017158 VESTS"
    }
  ]
}

{
  "trx_id": "633ca3e450a1124d2b983cd4d7a94073cb2b72f4",
  "block": 43216055,
  "trx_in_block": 7,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-05-09T04:54:03",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "7765.233649 VESTS"
    }
  ]
}

{
  "trx_id": "e3594272c063016eafa4e6d0f5e3d6364be9d976",
  "block": 43192004,
  "trx_in_block": 4,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2020-05-08T08:22:45",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "1953.311140 VESTS"
    }
  ]
}

{
  "trx_id": "f76a04ad8dc03e5851138f94130512597ef0440a",
  "block": 34067451,
  "trx_in_block": 3,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2019-06-24T02:23:48",
  "op": [
    "comment",
    {
      "parent_author": "debuglove",
      "parent_permlink": "video",
      "author": "steemitboard",
      "permlink": "steemitboard-notify-debuglove-20190624t022347000z",
      "title": "",
      "body": "Congratulations @debuglove! You received a personal award!\n\n<table><tr><td>https://steemitimages.com/70x70/http://steemitboard.com/@debuglove/birthday2.png</td><td>Happy Birthday! - You are on the Steem blockchain for 2 years!</td></tr></table>\n\n<sub>_You can view [your badges on your Steem Board](https://steemitboard.com/@debuglove) and compare to others on the [Steem Ranking](https://steemitboard.com/ranking/index.php?name=debuglove)_</sub>\n\n\n**Do not miss the last post from @steemitboard:**\n<table><tr><td><a href=\"https://steemit.com/steemitboard/@steemitboard/the-steem-community-has-lost-an-epic-member-farewell-woflhart\"><img src=\"https://steemitimages.com/64x128/https://cdn.steemitimages.com/DQmQWnM36SWCPGn98nY83M1ArgweMz5fnovQEp2E4FiDdug/Wolfhart_header.png\"></a></td><td><a href=\"https://steemit.com/steemitboard/@steemitboard/the-steem-community-has-lost-an-epic-member-farewell-woflhart\">The Steem community has lost an epic member! Farewell @woflhart!</a></td></tr><tr><td><a href=\"https://steemit.com/steemtoolbar/@steemitboard/steemtoolbar-update-display-bug-fixed\"><img src=\"https://steemitimages.com/64x128/http://i.cubeupload.com/7CiQEO.png\"></a></td><td><a href=\"https://steemit.com/steemtoolbar/@steemitboard/steemtoolbar-update-display-bug-fixed\">SteemitBoard - Witness Update</a></td></tr><tr><td><a href=\"https://steemit.com/steem/@steemitboard/do-not-miss-the-coming-rocky-mountain-steem-meetup-and-get-a-new-community-badge\"><img src=\"https://steemitimages.com/64x128/https://cdn.steemitimages.com/DQmUphCGZFWgt6bJ1XTtunV7esnwy6bxnGqcLcHAV3NEqnQ/meetup-rocky-mountain.png\"></a></td><td><a href=\"https://steemit.com/steem/@steemitboard/do-not-miss-the-coming-rocky-mountain-steem-meetup-and-get-a-new-community-badge\">Do not miss the coming Rocky Mountain Steem Meetup and get a new community badge!</a></td></tr></table>\n\n###### [Vote for @Steemitboard as a witness](https://v2.steemconnect.com/sign/account-witness-vote?witness=steemitboard&approve=1) to get one more award and increased upvotes!",
      "json_metadata": "{\"image\":[\"https://steemitboard.com/img/notify.png\"]}"
    }
  ]
}

{
  "trx_id": "5d66c7e083b5e01fec93bd49b048a4d20b125d94",
  "block": 33826546,
  "trx_in_block": 11,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2019-06-15T17:14:51",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "7954.001880 VESTS"
    }
  ]
}

{
  "trx_id": "35bc770dc64ae0b7cea255d6c8abd57595cdefbb",
  "block": 31433427,
  "trx_in_block": 8,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2019-03-24T12:11:51",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "remove",
      "author": "debuglove",
      "permlink": "how-to-remove-warts-in-delicate-areas-just-using-lemons",
      "title": "[Deleted]",
      "body": "[Deleted]",
      "json_metadata": "{\"app\":\"steemit/0.1\",\"format\":\"markdown\",\"tags\":[\"remove\"]}"
    }
  ]
}

{
  "trx_id": "2c7659dc3e32505c46a615c6b5ec2bfe000cafa9",
  "block": 31433423,
  "trx_in_block": 37,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2019-03-24T12:11:39",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "remove",
      "author": "debuglove",
      "permlink": "how-to-remove-warts-in-delicate-areas-just-using-lemons",
      "title": "[Deleted]",
      "body": "[Deleted]",
      "json_metadata": "{\"app\":\"steemit/0.1\",\"format\":\"markdown\",\"tags\":[\"remove\",\"warts\"]}"
    }
  ]
}

{
  "trx_id": "58a971b108a0d46545fbd9ca56647d729b39b330",
  "block": 23587504,
  "trx_in_block": 3,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-06-24T00:00:36",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "8153.103570 VESTS"
    }
  ]
}

{
  "trx_id": "9446e5d23e203d843ea7f7a47c4552b6b62146da",
  "block": 22546086,
  "trx_in_block": 7,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-05-18T19:09:42",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "28518.707325 VESTS"
    }
  ]
}

{
  "trx_id": "c7fb6087a8d36dd5e111ec235766745ff248bba8",
  "block": 20967751,
  "trx_in_block": 6,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-03-24T23:05:18",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "regex",
      "author": "debuglove",
      "permlink": "video",
      "title": "Video",
      "body": "Sorry reformulating contents of my post...",
      "json_metadata": "{\"tags\":[\"regex\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "f4206ee97910913fa27d477e7543dd7a952a7e59",
  "block": 20967738,
  "trx_in_block": 21,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-03-24T23:04:39",
  "op": [
    "vote",
    {
      "voter": "raise-me-up",
      "author": "debuglove",
      "permlink": "video",
      "weight": 2
    }
  ]
}

{
  "trx_id": "cb43f5b96dafe3464b9079f861b0a6bb9bdc50ee",
  "block": 20967703,
  "trx_in_block": 16,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-03-24T23:02:54",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "regex",
      "author": "debuglove",
      "permlink": "video",
      "title": "Video",
      "body": "Regex",
      "json_metadata": "{\"tags\":[\"regex\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "14f7ec3a691d4afb9cfe3643f27f1622ecd9ff66",
  "block": 20700055,
  "trx_in_block": 18,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-03-15T15:16:30",
  "op": [
    "vote",
    {
      "voter": "palythnobinklus",
      "author": "debuglove",
      "permlink": "what-kind-of-specimen-is-this",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "28d244096a36a61bd932f766134af285fd221d2a",
  "block": 20687406,
  "trx_in_block": 39,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-03-15T04:42:42",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "what",
      "author": "debuglove",
      "permlink": "what-kind-of-specimen-is-this",
      "title": "What kind of specimen is this",
      "body": "I found this snake type animal in my garden. It has around 80 cm to 1meter.  Does anyone knows it? Is it poisounous?\n\n![DSC04744.JPG](https://steemitimages.com/DQmd7pk2hMF3bqVHLyQWhzRobzZD2ncSaTEZGUy1ShZGqf9/DSC04744.JPG)\n\n![DSC04745.JPG](https://steemitimages.com/DQmde67DjtpvFBVyfB2XKWDFav361WHP2X5W8gm6LJNGVrQ/DSC04745.JPG)![DSC04746.JPG](https://steemitimages.com/DQmQrDG7huPPxsPXNAsRzhAgt14mSvwXhCPwbbB7sWJjx47/DSC04746.JPG)![DSC04742.JPG](https://steemitimages.com/DQmV4rTCwmUoNx2fy7CrGhmYjo6sHJyZp9gW3NDTpGPv8yg/DSC04742.JPG)![DSC04741.JPG](https://steemitimages.com/DQmRaBDnnY2RCxSpAVS32UCprSP93RJafDaYT41KuZgBaEJ/DSC04741.JPG)![DSC04740.JPG](https://steemitimages.com/DQmddu1hB3iPSRes9usSoibRvGn5dUYaC9ucijdX8Yo17Xx/DSC04740.JPG)![DSC04750.JPG](https://steemitimages.com/DQmVujpxYnMRzDBxa7XmtzQXvWFtxAA8ieyacyKNPdMb6kw/DSC04750.JPG)![DSC04749.JPG](https://steemitimages.com/DQmSHzSJbeLzzpyTbZKswLMgLto9A5QJgpYfiMJTcExqw8B/DSC04749.JPG)",
      "json_metadata": "{\"tags\":[\"what\",\"is\",\"this\"],\"image\":[\"https://steemitimages.com/DQmd7pk2hMF3bqVHLyQWhzRobzZD2ncSaTEZGUy1ShZGqf9/DSC04744.JPG\",\"https://steemitimages.com/DQmde67DjtpvFBVyfB2XKWDFav361WHP2X5W8gm6LJNGVrQ/DSC04745.JPG\",\"https://steemitimages.com/DQmQrDG7huPPxsPXNAsRzhAgt14mSvwXhCPwbbB7sWJjx47/DSC04746.JPG\",\"https://steemitimages.com/DQmV4rTCwmUoNx2fy7CrGhmYjo6sHJyZp9gW3NDTpGPv8yg/DSC04742.JPG\",\"https://steemitimages.com/DQmRaBDnnY2RCxSpAVS32UCprSP93RJafDaYT41KuZgBaEJ/DSC04741.JPG\",\"https://steemitimages.com/DQmddu1hB3iPSRes9usSoibRvGn5dUYaC9ucijdX8Yo17Xx/DSC04740.JPG\",\"https://steemitimages.com/DQmVujpxYnMRzDBxa7XmtzQXvWFtxAA8ieyacyKNPdMb6kw/DSC04750.JPG\",\"https://steemitimages.com/DQmSHzSJbeLzzpyTbZKswLMgLto9A5QJgpYfiMJTcExqw8B/DSC04749.JPG\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "aea57bd26beb71a83667c1e8aa9a92289621fc16",
  "block": 18819541,
  "trx_in_block": 24,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2018-01-09T06:37:03",
  "op": [
    "delegate_vesting_shares",
    {
      "delegator": "steem",
      "delegatee": "debuglove",
      "vesting_shares": "28724.376692 VESTS"
    }
  ]
}

{
  "trx_id": "0000000000000000000000000000000000000000",
  "block": 16730019,
  "trx_in_block": 4294967295,
  "op_in_trx": 0,
  "virtual_op": 49,
  "timestamp": "2017-10-28T16:22:39",
  "op": [
    "curation_reward",
    {
      "curator": "debuglove",
      "reward": "2.055880 VESTS",
      "comment_author": "x22report",
      "comment_permlink": "this-massive-everything-bubble-is-about-to-pop-and-it-s-going-to-be-a-disaster-jason-burack"
    }
  ]
}

{
  "trx_id": "0000000000000000000000000000000000000000",
  "block": 16642110,
  "trx_in_block": 4294967295,
  "op_in_trx": 0,
  "virtual_op": 21,
  "timestamp": "2017-10-25T15:03:03",
  "op": [
    "curation_reward",
    {
      "curator": "debuglove",
      "reward": "2.056202 VESTS",
      "comment_author": "zikra",
      "comment_permlink": "flat-design-character-like-kurzgesagt"
    }
  ]
}

{
  "trx_id": "2a7ccfd5f74a7cb31994d7aff38074372361b9bd",
  "block": 16530390,
  "trx_in_block": 29,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-10-21T17:54:57",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "x22report",
      "permlink": "this-massive-everything-bubble-is-about-to-pop-and-it-s-going-to-be-a-disaster-jason-burack",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "06745f16b8f217bdeae9c92c82ed72b7911cad40",
  "block": 16442425,
  "trx_in_block": 8,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-10-18T16:34:06",
  "op": [
    "vote",
    {
      "voter": "primetimesports",
      "author": "debuglove",
      "permlink": "how-to-remove-warts-in-delicate-areas-just-using-lemons",
      "weight": 2
    }
  ]
}

{
  "trx_id": "2cc8b0f5d196fde7d208ac56968037fc0e86e7dd",
  "block": 16441844,
  "trx_in_block": 15,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-10-18T16:05:03",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "remove",
      "author": "debuglove",
      "permlink": "how-to-remove-warts-in-delicate-areas-just-using-lemons",
      "title": "How to remove warts in delicate areas just using lemons",
      "body": "Helloooo everyone, coming out a little bit of my toughts of programming, i decided to share a little of my experience with a wart, which was probably the second i had in my life but it appeared in a very delicate area, just below my left eye. What would i do??? Well, the removers seamed to dangerous to use in any wart, let alone one belo my eyes. Look at the situation in day 1:\n\n![day1.jpg](https://steemitimages.com/DQmUV1WBp51WYQLPJo1YMT79zyDMk641V2z7x7qHLYHLUay/day1.jpg)\n\nI saw removers like pointtss and such. Soon i realized such aggressive treatments would not work especially in such area. unless i wanned to remove it at cost of my sight. Then ive read about bananas and lemons.  It was stupidly hard to fix the banana peel even for  a few minutes there, imagine let it there for a day or so. Then i decided to go with the lemon juice option. \n\nWhat i did was just cut a lemon in half and extract the juice of half of it and immerse some cotton over it, half a lemon in the morning and another half in the night. Then i would let the cotton in contact with the wart for 15 minutes in each application, so 30 mins a day. Sure, a few drops fell into my eyes, but no big issues there, you will survive. The results:\n\nday4:\n\n![day4.jpg](https://steemitimages.com/DQmeJoWPCvXbCtoNebvveGJP7nTqDL6sjYfoWaqcV8drgPS/day4.jpg)\n\nday5: \n\n![day5.jpg](https://steemitimages.com/DQmY84gWomNAQwU6uZ8qZETz3Q8qgDhAFGDhx2nzBC2rxw7/day5.jpg)\n\nday6: \n\n![day6.jpg](https://steemitimages.com/DQmP2KDDn6A6aYHmiuBPJhUc5UpBusLf9dEJmMZkDx1Gxv3/day6.jpg)\n\nday7: \n\n![day7.jpg](https://steemitimages.com/DQme5bNaTykwcfGgzGQqEhvrxof7r4DLLWUNSB7VQLqejgf/day7.jpg)\n\nday8:\n\n![day8.jpg](https://steemitimages.com/DQmUWrTrEFU7rXpw2mgDxj4bSQryxyF8WAW7iswe1dKmZx1/day8.jpg)\n\nday9:\n\n![day9.jpg](https://steemitimages.com/DQmYypHwpCmVxQEDukF8vMgmBDe3YZKTqx6ocHJRYCBiszu/day9.jpg)\n\n\nday10:\n\n![day10.jpg](https://steemitimages.com/DQmbQVuuZAsKU5cTzhgXQQn6wtzytiLYzCHPz5GzqAsZgUY/day10.jpg)\n\nday11: \n\n![day11.jpg](https://steemitimages.com/DQmbyE9FCnMLMSLbUgN5QdRKws7fwfgXeFAbmQFRRE68qQr/day11.jpg)\n\nday12:\n\n![day12.jpg](https://steemitimages.com/DQmQYEH2AMxz4xZ8kTm5tcaSu8zL2s3sNYhZPMuNahXigNx/day12.jpg)\n\n\nday16:\n\n![day16.jpg](https://steemitimages.com/DQmUVxJqDKVBRWiGXqXM7391tkMakhNPNNojm8J3mZFKbCo/day16.jpg)\n\n\nday18:\n\n![day18.jpg](https://steemitimages.com/DQmbxREmpzaP6LRQhM2LUj29BAtYmbWujdjERW7SkV6syCQ/day18.jpg)\n\nSo there you go. A good solution to your wart, cheap and not very aggressive. Hope it helps someone out there.",
      "json_metadata": "{\"tags\":[\"remove\",\"warts\"],\"image\":[\"https://steemitimages.com/DQmUV1WBp51WYQLPJo1YMT79zyDMk641V2z7x7qHLYHLUay/day1.jpg\",\"https://steemitimages.com/DQmeJoWPCvXbCtoNebvveGJP7nTqDL6sjYfoWaqcV8drgPS/day4.jpg\",\"https://steemitimages.com/DQmY84gWomNAQwU6uZ8qZETz3Q8qgDhAFGDhx2nzBC2rxw7/day5.jpg\",\"https://steemitimages.com/DQmP2KDDn6A6aYHmiuBPJhUc5UpBusLf9dEJmMZkDx1Gxv3/day6.jpg\",\"https://steemitimages.com/DQme5bNaTykwcfGgzGQqEhvrxof7r4DLLWUNSB7VQLqejgf/day7.jpg\",\"https://steemitimages.com/DQmUWrTrEFU7rXpw2mgDxj4bSQryxyF8WAW7iswe1dKmZx1/day8.jpg\",\"https://steemitimages.com/DQmYypHwpCmVxQEDukF8vMgmBDe3YZKTqx6ocHJRYCBiszu/day9.jpg\",\"https://steemitimages.com/DQmbQVuuZAsKU5cTzhgXQQn6wtzytiLYzCHPz5GzqAsZgUY/day10.jpg\",\"https://steemitimages.com/DQmbyE9FCnMLMSLbUgN5QdRKws7fwfgXeFAbmQFRRE68qQr/day11.jpg\",\"https://steemitimages.com/DQmQYEH2AMxz4xZ8kTm5tcaSu8zL2s3sNYhZPMuNahXigNx/day12.jpg\",\"https://steemitimages.com/DQmUVxJqDKVBRWiGXqXM7391tkMakhNPNNojm8J3mZFKbCo/day16.jpg\",\"https://steemitimages.com/DQmbxREmpzaP6LRQhM2LUj29BAtYmbWujdjERW7SkV6syCQ/day18.jpg\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "e69cd4751ff59508d107af8d4039827962d7194c",
  "block": 16441804,
  "trx_in_block": 6,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-10-18T16:03:03",
  "op": [
    "vote",
    {
      "voter": "jeffdud",
      "author": "debuglove",
      "permlink": "dynamic-memory-allocation-in-c",
      "weight": 500
    }
  ]
}

{
  "trx_id": "c7fab1d54952f84efc5eb4e9f0679123f81355f0",
  "block": 16441132,
  "trx_in_block": 24,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-10-18T15:29:27",
  "op": [
    "vote",
    {
      "voter": "zikra",
      "author": "debuglove",
      "permlink": "re-zikra-flat-design-character-like-kurzgesagt-20171018t150600767z",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "c7032af2d58185826a51d1887304f75dab00a79b",
  "block": 16441127,
  "trx_in_block": 16,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-10-18T15:29:12",
  "op": [
    "comment",
    {
      "parent_author": "debuglove",
      "parent_permlink": "re-zikra-flat-design-character-like-kurzgesagt-20171018t150600767z",
      "author": "zikra",
      "permlink": "re-debuglove-20171018t22292746z",
      "title": "",
      "body": "Thanks for your commenting \nI am just a beginner designer",
      "json_metadata": "{\"tags\":\"art\",\"app\":\"esteem/1.4.6\",\"format\":\"markdown+html\",\"community\":\"esteem\"}"
    }
  ]
}

{
  "trx_id": "f763b21cd918bd540ae2c18cfd29b43f5b20ef3b",
  "block": 16441022,
  "trx_in_block": 8,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-10-18T15:23:57",
  "op": [
    "vote",
    {
      "voter": "tokenteller",
      "author": "debuglove",
      "permlink": "dynamic-memory-allocation-in-c",
      "weight": 100
    }
  ]
}

{
  "trx_id": "43a38d0bcaf2c5cbd888e86b104f2243aa6ec205",
  "block": 16440838,
  "trx_in_block": 4,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-10-18T15:14:45",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "dynamic",
      "author": "debuglove",
      "permlink": "dynamic-memory-allocation-in-c",
      "title": "Dynamic Memory Allocation in C",
      "body": "@@ -5478,16 +5478,17 @@\n rl code \n+e\n ven more\n",
      "json_metadata": "{\"tags\":[\"dynamic\",\"memory\",\"allocation\"],\"image\":[\"https://steemitimages.com/DQmbzEDnvgT1d4VLoP8YMDjUq1D7Ej78a6DGuHNKYKgreuM/img1.jpg\",\"https://steemitimages.com/DQmbP5EpVkReDPyL3MXmkRW4EHU1EYcEyvbh3mgcP9men8D/IMG2.jpg\",\"https://steemitimages.com/DQmNcpab89HqhSQJ4xgNqhx8DDeTDBPgaCucrsWrW8yc5XV/img3.jpg\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "953199be23a4e5b7418d69655afbfdac31930aae",
  "block": 16440741,
  "trx_in_block": 4,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-10-18T15:09:54",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "zikra",
      "permlink": "flat-design-character-like-kurzgesagt",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "598c296aae2d178c4372907f84aecbe81524bcf9",
  "block": 16440680,
  "trx_in_block": 9,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-10-18T15:06:51",
  "op": [
    "comment",
    {
      "parent_author": "zikra",
      "parent_permlink": "flat-design-character-like-kurzgesagt",
      "author": "debuglove",
      "permlink": "re-zikra-flat-design-character-like-kurzgesagt-20171018t150600767z",
      "title": "",
      "body": "Cool. Can you animate already? I am not that great designer yet, but i make some animations for fun, however in am ashamed of posting them to other people see.",
      "json_metadata": "{\"tags\":[\"art\"],\"app\":\"steemit/0.1\"}"
    }
  ]
}

{
  "trx_id": "40c34b531b76c2ebe46064ded08aef19d1ef83b1",
  "block": 16440621,
  "trx_in_block": 11,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-10-18T15:03:54",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "dynamic",
      "author": "debuglove",
      "permlink": "dynamic-memory-allocation-in-c",
      "title": "Dynamic Memory Allocation in C",
      "body": "# Dynamic memory allocation\nAs a compiled language, in normal situations your datatypes will be evaluated when your program is being compiled. However, we can also assign values to our datatypes while the program is running. Imagine a situation where only the user and not the developer knows how big the array needs to be. In such situations, the programmer cannot declare the array while he writes his code. He must ask the user for the array size while his program is running. In interpreted languages, this would be no problem at all, since you can allocate variables while the program is running, but in C, a compiled language, we must go through extra steps to create dynamic variables.\n\n## Malloc and free\nWhen you declare a variable normally, it will be stored in a memory area of your program called the stack. A dynamic variable however will be stored in a memory area called heap. The more you allocate in heap memory, the less you can allocate in the stack without raising issues and warnings, and vice versa. Thats because the heap and the stack grow in opposite directions, and if they get close to each other, thats when problems start. \n\n![img1.jpg](https://steemitimages.com/DQmbzEDnvgT1d4VLoP8YMDjUq1D7Ej78a6DGuHNKYKgreuM/img1.jpg)\n\n\nThe basic functions C provides for us to allocate dynamic memory are malloc and free. Malloc(from memory allocation) will allocate a pointer with the size in bytes you specify in the as argument to the function:\n\n---\n\n>void *p = malloc(25);\n\n---\n\nMalloc now has allocated a n bytes (25 in the example above) to be stored in the heap of your program and returns the adress where you allocated it in the pointer. The problem here is, those bytes will remain there as long as your program is running, and it doesnt matter if you are outside of the scope you declared your pointer or even if your function has returned. Unlike the stack, these bytes will remain in the heap, consuming resources of your program. For instance, in a situation like below:\n\n---\n\n>int main()\n>{\n\n\t\t\n>f();\n>return 0;\n}\n>f() {\n\tvoid *p = malloc(4);\n}\n\n---\n\nAltough our function f() where we allocated 4 bytes to the pointer p has returned, those bytes will still be allocated in the heap, unlike when we do it in the stack.\n\nIn this context, we must use the function free, passing the pointer which was initialized with the malloc function to release these bytes from the heap. \n\n---\n\n>f() {\n>void *p = malloc(4);\n>free(p);\n>}\n\n---\n\nThats one aspect of C which is different from higher level programming languages. You must remember to use free to release memory allocated on the heap, unlike programming languages like java or c# which take care of everything for you. This could be a good thing or bad sometimes. \n\nAltough malloc can only understand the size in bytes you need to allocate as an argument, and doesnt know about different datatypes, it is possible to format the arguments you pass as a datatype value instead of a raw number, so we dont have to calculate the exact amount of bytes everytime:\n\n---\n\n>void *p = malloc(sizeof(int));\n \n---\n\nMalloc allocates memory in contiguous memory adresses. So lets say you you've allocated 10 bytes and 20 bytes right after. If you free the first pointer, and allocate a new pointer with 15 bytes, these bytes will be allocated in after the second pointer(with 20 bytes in size). This can leave gaps in your heap, but like we have seen in structs, it is a faster way to acess memory adresses with one acess, instead of spreading the allocated bytes and performing more than acess through different adresses.\n\n![IMG2.jpg](https://steemitimages.com/DQmbP5EpVkReDPyL3MXmkRW4EHU1EYcEyvbh3mgcP9men8D/IMG2.jpg)\n\n\nBut what about dynamic allocation and user interaction we menationed previously? Yeah, lets ask our user whats the size of the array while the program is running(at runtime):\n\n---\n\n>int *array;\n\n>int p;\n>printf(\"Declare the array size\\n\");\n>scanf(\"%d\", &p);\n\n>array = malloc(p * sizeof(int));\n\n>for (int i = 0; i < p; i++) {\n\t\tint val;\n\t\tprintf(\"declare the value of position %d\\n\", i);\n\t\tscanf(\"%d\", &val);\n\t\tarray[i] = val;\n\t\t\n>}\n\n>for (int i = 0; i < p; i++) {\n\t\tprintf(\"array[%d] = %d\\n\", i, array[i]);\n\t}\n\t\n>return 0;\n\n---\n\n![img3.jpg](https://steemitimages.com/DQmNcpab89HqhSQJ4xgNqhx8DDeTDBPgaCucrsWrW8yc5XV/img3.jpg)\n\nNice isnt. Scanf will get the input value adress and return the value at runtime and malloc will allocate the array size at runtime. I believe you, like me, have imagined why is this necessary, for example, if we want to declare a name but we dont know beforehand how big it is, if we declare the array with 100 elements, its possible some space is just being wasted, at least i myself know a short list of names with more than 100 characters lol. On the other hand, if we declare an array with only 3 elements, well, i believe your name might not be so short. Why not let the user declare the array size then? In the previous example, our user not only can specify the array size with malloc, but also the elements values at each position with the scanf in the for loop.\n\nIn higher level programming languages we would have so much less work wouldnt we? Lets take a look how we would do it in perl since i have my eclipse opened:\n\n---\n>print(\"Input array size\\n\");\n$size = <>;\n\n><code>@</code>array = ();\nfor($i = 0; $i < $size; $i++) {\n\t$element = <>;\n\tpush <code>@</code>array, $element;\n}\n>print (@array);\n\n---\n\nSweet isnt? to be honest we could have done this perl code ven more compact than it is, but i wanned you to see and trace parallels between this code and the C code you have saw. In perl, not only the aray and variables are already dynamic declared, but they also can contain any type of elements, not only int or float and such, so the same aray could contain any type of data, form numbers to strings or even arrays and hashs. Why am i quoting this? Well, just another tought which came to my mind, when you learn a few languages you will also compare them, if you already dont, but i think its still usefull, afterall pick the right tool for the right job, and anyways, perl also has a good amount of C in its core, and so do many languages. C is in the core of many technologies, so it will be very usefull to learn and analyse it as a debugger.\n\n\n\nNow, lets just say we ned more heap memory later in the code. We can resize the memory allocated with command realloc if we must modify it later:\n\n---\n\n>void *p = NULL;\n>p =  realloc(p, 16);\n\n---\n\n## Common Errors with dynamic memory allocation\n\n\n When you allocate dynamic memory, its not possible to free only a portion of the memory which was allocated. We could free using pointer arithmetic, but the thing is, we can only point to the adress of the memory allocation adress. So it would be valid to use this arithmetic on free:\n\n---\n\n>int *array;\n>array = malloc(25);\n\n>free(array + 2 - 3 + 1);\n\n---\n\nBut if we try to release only part of this memory we would get nasty errors:\n\n---\n\n>int *array;\n\tarray = malloc(25);\n\n>free(array + 2);\n\n---\n\nAcessing values which had been freed may also generate problems to your code. Some of them are silent. For example, lets initialize a value and free it right after, then try to acess it:\n\n---\n\n>int *array;\n>array = malloc(25);\n\tarray[1] = 25;\n\tfree(array);\n\n\t\n>printf(\"%d\", array[1]);\n\n\n>return 0;\n\n---\n\nThe chances are high your compiler will not raise any warnings, however you program might not be happy to acess dirty values values at some point.\n\nAnother bug harder to spot than the previous is to try acess values beyond the memory allocated. Lets take the sample code from before:\n\n---\n\n>int *array;\n\tarray = malloc(25);\n\tarray[1] = 25;\n\tfree(array);\n\n---\n\nNow lets say we try to acess element 30 of the array, or element -1. If your program is holding no values at that space, the bug may run quietly during your code lifecicle, but imagine if you assign a value there and theres already an important value at that space.  An important value could erase or even your program could terminate witx exceptions!\n\nWhen you are using free, you must use a pointer previously allocated with malloc. Passing a pointer not dinamically allocated may cause the program to terminate before it starts or later(which is worst).",
      "json_metadata": "{\"tags\":[\"dynamic\",\"memory\",\"allocation\"],\"image\":[\"https://steemitimages.com/DQmbzEDnvgT1d4VLoP8YMDjUq1D7Ej78a6DGuHNKYKgreuM/img1.jpg\",\"https://steemitimages.com/DQmbP5EpVkReDPyL3MXmkRW4EHU1EYcEyvbh3mgcP9men8D/IMG2.jpg\",\"https://steemitimages.com/DQmNcpab89HqhSQJ4xgNqhx8DDeTDBPgaCucrsWrW8yc5XV/img3.jpg\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "1273aff9aecf5303028e3492ee718935591aa5d0",
  "block": 16218366,
  "trx_in_block": 42,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-10-10T21:27:03",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "x22report",
      "permlink": "the-cabal-just-hit-a-brick-wall-here-s-what-happened-episode-1396b",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "58a1ab6783df96ef872a67b57db780ee77f02c90",
  "block": 16218364,
  "trx_in_block": 3,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-10-10T21:26:57",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "themoneygps",
      "permlink": "rl9ddshf",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "c3b23c9ab9bd5eec9b7fca1f26d61592f8100ef3",
  "block": 15915797,
  "trx_in_block": 18,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-09-30T09:06:03",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "themoneygps",
      "permlink": "k9hqywd5",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "f75302b8ecde455eb04a81ba994f167254a20f2b",
  "block": 15915796,
  "trx_in_block": 20,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-09-30T09:06:00",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "themoneygps",
      "permlink": "jkx78xj4",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "d1db4b74e745576a71bba91dd04ba0b6273433c0",
  "block": 15732383,
  "trx_in_block": 10,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-09-24T00:12:33",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "bobbyc249",
      "permlink": "feminism-destroys-women-and-society-and-violates-natures-law",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "72a5c03b1ef1985253c5dbd6ea2941ea2dd1fb67",
  "block": 15732277,
  "trx_in_block": 4,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-09-24T00:07:15",
  "op": [
    "custom_json",
    {
      "required_auths": [],
      "required_posting_auths": [
        "debuglove"
      ],
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"debuglove\",\"following\":\"bobbyc249\",\"what\":[\"blog\"]}]"
    }
  ]
}

{
  "trx_id": "e980e5648b481491183b1809df95c40a2cbc3ea5",
  "block": 15722222,
  "trx_in_block": 30,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-09-23T15:44:15",
  "op": [
    "custom_json",
    {
      "required_auths": [],
      "required_posting_auths": [
        "debuglove"
      ],
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"debuglove\",\"following\":\"wayforhappiness\",\"what\":[\"blog\"]}]"
    }
  ]
}

{
  "trx_id": "dc8408864ff0883cfb6573df13e7980f19e386d6",
  "block": 15661842,
  "trx_in_block": 19,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-09-21T13:25:09",
  "op": [
    "custom_json",
    {
      "required_auths": [],
      "required_posting_auths": [
        "debuglove"
      ],
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"debuglove\",\"following\":\"minnow.helper\",\"what\":[\"blog\"]}]"
    }
  ]
}

{
  "trx_id": "6c47f7d7889f3587fe63de4239e165175595d66f",
  "block": 15640635,
  "trx_in_block": 11,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-09-20T19:44:21",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "structs",
      "author": "debuglove",
      "permlink": "structs-and-unions-in-c",
      "title": "Structs and Unions in C",
      "body": "In previous threads, we have seen how arrays can contain more than one valoue in one container. However, arrays can only contain values of the same datatype. In C, we can store values of different dataypes in in the same container. To do this kind of operation, storing different types in a single container, we will use structures and unions. \n\n## Structures\nA structure is an aggregate dataype, like an array. In arrays, each individual item can be selected using its subscript or through a pointer indirection. In structures, each member receives a name to be acessed, since each of them could have a different size, making the acess trough arithmetic very cumbersome. \nA struct may contain a tag, which allow its variable members to be called by a name, a body delimited by curly braces containing its members and the variable list. \nThe prototype of a structure is:\n\n---\n\n\tstruct tag {members} variables;\n\n---\n\n\nThe tag and variables fields are optional.\nLets create a simple structure to demonstrate:\n\n---\n\n\tstruct {\n\t\tint x;\n\t\tchar y;\n\t\tdouble z;\n\t} s;\n\n---\n\nHere we have a strutucture containing 3 members, a int, a char and a double variables. The variable list is declared as s. Declaring the structure with the s variable is like declaring a variable, lets say an int and giving it a name s:\n\n---\n\n\tint s\n\n---\n\nSo, as we can declare more than variables of the same type in one line:\n\n---\n\n\tint s1, s2, s3;\n\n---\n\nwe can also do the same with structs:\n\n---\n\n\tstruct {\n\t\tint x;\n\t\tchar y;\n\t\tdouble z;\n\t} s1, s2, s3;\n\n---\nNow, we have 3 different structs variables containing the same datatypes in its bodies.\n\nThe tag field allows us to call subsequent declarations with a name, even if we havent declared a variable list, now they can be declared in separate instructions by using the struct tag to associate the variable with the tagged struct.\n\n---\n\n\tstruct tagged {\n\t\tint x;\n\t\tint y;\n\t\tdouble z;\n\t};\n\tstruct tagged s1;\nstruct tagged s2;\n\n---\n\n\nNow we have a struct with no variable list but with a tag called tagged. \nArrays of structs, pointers to structs and even structs of structs are allowed, however, a struct cannot contain itself as one of its members, so the following code would be invalid:\n\n---\n\nstruct tagged {\n\t\tint x;\n\t\tint y;\n\t\tdouble z;\n\t\tstruct tagged pg;\n} f;\n\n---\n\nNow, the arrays of structs, pointers to structs and another struct within a struct, you would have no problem:\n\n---\n\n\tstruct lolo {\n\t\tint po;\n\t} p;\n\t\n\tstruct tagged {\n\t\tint x;\n\t\tint y;\n\t\tdouble z;\n\t\tstruct lolo pg;\n\t} f[20], *g;\n\n\tstruct tagged s1;\n\treturn 0;\n\n---\n\nIf you are coming from an object oriented programming language, the structs may remind you of classes and objects you are used to work with. In fact, languages like C# have their own structs datatypes. However they are more advanced structs than C, being similar to classes themselves, being capable of creating methods (methods are like functions which belong to a class), constructors, and even more, depending of the programming language you are working with.\n\nWe can also declare subsequent structs without tags, using the keyword typedef(If you remember, typedef will define a new name for a C datatype):\n\n---\n\n\ttypedef struct {\n\t\tint point1;\n\t\tint point2;\n\t\tint point3;\n\t} triangle;\n\n\ttriangle t1;\n\ttriangle t2;\n\n---\n\n### Acessing member of the struct\nThe members of the struct can be acessed with the dot(.) operator.\n\n---\n\n\ttypedef struct {\n\t\tint point1;\n\t\tint point2;\n\t\tint point3;\n\t} triangle;\n\n\ttriangle t1;\n\t\n\n\tt1.point1 = 15;\n\tt1.point2 = 30;\n\tt1.point3 = 23;\n\n\tprintf(\"triangle points are %d, %d, %d\\n\", t1.point1, t1.point2, t1.point3);\n\n---\n\n![img1.jpg](https://steemitimages.com/DQmajLLa2RvnjYMAykzLnYqhNKdS9c5RfSg2k2SpadH22L7/img1.jpg)\n\n\nAs we can see, the left operand of the dot is the struct name and the right operand is the name of the member.\nNow lets create a struct inside another struct. To acess the members of the struct inside the struct, all we have to dot is keep adding dots for each nested struct:\n\n---\n\n\tstruct s1 {\n\t\tint x;\n\t};\n\n\ttypedef struct {\n\t\tstruct s1 n ;\n\t} nest;\n\n\tnest n1;\n\tn1.n.x = 13;\n\n\tprintf(\"nest member: %d\\n\", n1.n.x);\n\n---\n\n\n![img2.jpg](https://steemitimages.com/DQmeCfvZZAXPm3ZuaxQQuJPVN3cdoifzygAFMVxLtCe54LE/img2.jpg)\n\n\nIn the last example, we have a struct s1 containig an int x, inside the defined struct nest containing a variable n of the type s1. We then declare a variable of type n1. Since we have to acess a variable inside a struct from n1, all we had to do is add another dot to reach the member inside n from n1.\n\nStructs members can also be initialized when declaring the struct. All you have to do is declare your struct, name it and add the values to each member inside a curly brackets:\n\n---\n\n\tstruct s1 {\n\t\tint a;\n\t\tint b;\n\t\tint c;\n\t} st = {5, 10, 15};\n\n\tprintf(\"%d, %d, %d\\n\", st.a, st.b, st.c);\n\n---\n\n\n![img3.jpg](https://steemitimages.com/DQmSrt4j1QqXQRPMuPbQ5t6JKrB4NhCN4BH5hrXyTtqZQ8w/img3.jpg)\n\nWe can see also another important behavior if you are perceptive. When you declare a struct, the struct becomes a datatype itself. Again if you are coming from an object oriented language, the same happens when you declare a class. Your struct now can can be used in the same contexts as a datatype, even being able to be passed as a argument to a function.\n\n\n\n### Acessing structs members indirectly\n\nWith the dot operator, we can acess structs members directly. But what happens if we have a pointer to a struct, like the exemple below:\n\n---\n\n\tstruct s1 {\n\t\tint x;\n\t\tint y;\n\t};\n\n\tstruct s1 st;\n\tst.x = 88;\n\tst.y = 16;\n\n\tstruct s1 *ps = &st;\n\n---\n\n\t\nIn this case, there are 2 possibilities for us. Both perform the same operation, all that changes is the way we write our code, so whatever works for you. We can dereference the pointer with the * operator inside a parenthesis(because we must no forget the precedence), or we could dereference with the arrow operator:\n\n---\n\n\tstruct s1 {\n\t\tint x;\n\t\tint y;\n\t};\n\n\tstruct s1 st;\n\tst.x = 88;\n\tst.y = 16;\n\n\tstruct s1 *ps = &st;\n\n\tprintf(\"struct element 1: %d\\n\", (*ps).x);\n\tprintf(\"struct element 1: %d\\n\", (*ps).y);\n\n\tprintf(\"struct element 1: %d\\n\", ps->x);\n\tprintf(\"struct element 1: %d\\n\", ps->y);\n\n\treturn 0;\n\n---\n\n![img4.jpg](https://steemitimages.com/DQmUehMQNCuwQQr4vniN4iEkxCseah63CqNr4RLB7qJ57Rh/img4.jpg)\t\n\n\nBut why use a pointer to a a struct afterall? Well, since structs can become big data structures and contain many members, it would be expensive to do certain operations with them, like passing them to functions, everytime a function is called. So like a big array, it would be best to pass just a pointer to the struct instead of the whole struct and all its member elements.\n\n\n### Structs with referenced to themselves\nA struct cannot contain another struct of the same type inside itself. Imagine what would happen to the compiler, since it doesnt know yet the size of the struct and what kind of elements it contain, how it could contain a copy of itself inside of it without knowing this kind of information?\nIf that would happen, the program would recurse the struct forever trying to get information about itself. One solution for this problem, is to insert a pointer which has a known size poiting to the struct itself:\n\n---\n\n\tstruct s1 {\n\t\tint x;\n\t\tint y;\n\t\tstruct s1 *ms;\n\t};\n\n---\n\n\n### Structs Alignment\n\nTo demonstrate the importance of elements alignment in structs, i would like to begin by showing the following sample code:\n\n---\n\nstruct s1 {\n\t\tint a;\n\t\tchar b;\n\t\tint c;\n\t\tchar d;\n\t};\n\t\n\tstruct s2 {\n\t\tint a;\n\t\tint b;\n\t\tchar c;\n\t\tchar d;\n\t};\n\n\tstruct s1 d1;\n\tstruct s2 d2;\n\n\tprintf(\"struct 1 size: %d\\n\", sizeof(d1));\t\n\tprintf(\"struct 2 size: %d\\n\", sizeof(d2));\n\t\n\n\treturn 0;\n\n---\n\n\n![img5.jpg](https://steemitimages.com/DQmV3fsw7pgrygtoiskRx8bYtCbiMSi7XVAYHPoiRyBKw4H/img5.jpg)\n\n\nIn this code, we have 2 structs, with the same datatypes, 2 ints and 2 chars each. However, struct 1 has a size of 16 bytes, and struct 2 has a size of 12 bytes. The only difference between them is the order in which its elements are declared. So why struct 1 is bigger than struct 2? Struct 1 doesnt have its members aligned to optimze its size, while struct 2 does. IA 32 its optimized to acess datatypes trough 1 memory acess, altough it can acess datatypes trough fetching the memory more than once. So we have this situation in our struct 2 where, altough the sum of its elements would be 10 bytes (int = 4 bytes, char = 1 byte), we have its size designated as 12 bytes:\n\n\n![img struct2.jpg](https://steemitimages.com/DQmXAQC5SgWS4dnXYdp9w25XaaWaDy44Z1EWmurpEp6L6nM/img%20struct2.jpg)\n\nWhat happens is our elements are allocated in memory for optimal retrieval, with 1 acess according to the memory alignment, which has its memory adress being adressed from 4 to 4 bytes. \nNow lets take a look at the memory image of struct 1 elements:\n\n\n![img struct1.jpg](https://steemitimages.com/DQmWHByjJQnrCkPhCtwPnPYhzhpP4kxTuURjRNcFh8zi21W/img%20struct1.jpg)\n\nIn this poor illustration i made(sorry, not that good designer), we can see its elements are still alligned from 4 to 4 bytes. When we allocate an int it will take its first place at the first memory adress designated for the struct, but when we declare a char after the int, it will take its memory space, reserve the size of 1 byte to allocate its contents there, and then leave a gap of 3 bytes. What would happen if that gap didnt exist? If our next element was an int with 4 bytes for example, it would have to fetch the memory twice:\n\n\n![strut not opmitized.jpg](https://steemitimages.com/DQmQCpyhKUqkGcad2p25XUhwmGmn66C5ySzvjWR2CVVPwJZ/strut%20not%20opmitized.jpg)\n\nIn the illustration, we can see it would take the 3 free bytes remaining in memory adress A2, plus 1 free byte from memory adress A3, forcing the acess of 2 adresses, A2 and A3. Since IA32 will attemmpt to get the elements trough just 1 acess, it will just leave gaps with free memory like the image of struct 1. \nIf we want to decrease those gaps as much as we can, we must declare struct elements like we did with struct 2, with the bigger datatypes being declared first, followed by the smallest being declared last.\n\n\n## UNIONS\nUnions are similar to structs, being declared in the same way, and being able to contain different datatypes:\n\n---\n\n\tunion u1 {\n\t\tint a;\n\t\tint b;\n\t\tint c;\n\t};\n\n---\n\nUnion members can be acessed with the dot operator:\n\n---\n\n\tunion u {\n\t\tint a;\n\t\tfloat b;\n\t\t\n\t};\n\tunion u u1;\n\tu1.a = 21;\n\tu1.b = 27.0;\n\n---\n\nUnions will allocate space only for the biggest member datatype it contains. If your union contains a char and a int, the union will allocate 4 bytes. If it contains a int and a double, its size will be  8 bytes:\n\n---\n\n\tunion u {\n\t\tint a;\n\t\tdouble b;\n\t\t\n\t};\n\n\tunion u u1;\n\tu1.a = 21;\n\tu1.b = 27.0;\n\tprintf(\"u1 size, %d\\n\", sizeof(u1));\n\n---\n\n![img6.jpg](https://steemitimages.com/DQme8LukjcVqh66tdcwBBcjKwSYc2aQyT5Te1xVY9MQvPiy/img6.jpg)\n\n\nThat means they ocuppy less space than structs if they have more than one member and the same datatypes. In fact this is one of its main characteristics, unions will allocate all its members in the same memory adress, unlike structs. \nBut here is another different behavior of unions from structs. Since they all occupy the same memory adress, if you asign a different value to more than a member, it will affect the previous members:\n\n---\n\n\tunion u {\n\t\tint a;\n\t\tint b;\n\t\t\n\t};\n\n\tunion u u1;\n\tu1.a = 21;\n\tu1.b = 29;\n\t\n\t\n\tprintf(\"%d, %d\\n\", u1.a, u1.b);\n\n---\n\n![img7.jpg](https://steemitimages.com/DQmbnB8vZuhVvExn9kgtJ2Vwo2qt8FWWFoGcXgokmibYeo3/img7.jpg)\n\n\nUnions can also be initialized in one line, like structs:\n\n---\n\n\tunion u {\n\t\tshort a;\n\t\tint b;\n\t\t\n\t} u1 = {21};\t\n\t\n\tprintf(\"%d, %d\\n\", u1.a, u1.b);\t\n\n\treturn 0;\t\n\n---\n\n![img8.jpg](https://steemitimages.com/DQmSZdGNY6feyJMtFS3WdALk6fzBqsV9DAi6hRCxbq63CgP/img8.jpg)\n\nUnions can be a alternative to implement a type of polymorphism in C. In higher level programming languages, you probably very used to work with polymorphism, depending on how a object is called, it can have different behaviors, like implementing a method in different ways, depending on how it was called using one of its parents, interfaces and such. However in C unions, this kind of behavior is very limited.Structs and unions provide a way to not only to group different datatypes in one, but also agregate code and behavior, like passing them to functions in a primitive way.",
      "json_metadata": "{\"tags\":[\"structs\",\"and\",\"unions\"],\"image\":[\"https://steemitimages.com/DQmajLLa2RvnjYMAykzLnYqhNKdS9c5RfSg2k2SpadH22L7/img1.jpg\",\"https://steemitimages.com/DQmeCfvZZAXPm3ZuaxQQuJPVN3cdoifzygAFMVxLtCe54LE/img2.jpg\",\"https://steemitimages.com/DQmSrt4j1QqXQRPMuPbQ5t6JKrB4NhCN4BH5hrXyTtqZQ8w/img3.jpg\",\"https://steemitimages.com/DQmUehMQNCuwQQr4vniN4iEkxCseah63CqNr4RLB7qJ57Rh/img4.jpg\",\"https://steemitimages.com/DQmV3fsw7pgrygtoiskRx8bYtCbiMSi7XVAYHPoiRyBKw4H/img5.jpg\",\"https://steemitimages.com/DQmXAQC5SgWS4dnXYdp9w25XaaWaDy44Z1EWmurpEp6L6nM/img%20struct2.jpg\",\"https://steemitimages.com/DQmWHByjJQnrCkPhCtwPnPYhzhpP4kxTuURjRNcFh8zi21W/img%20struct1.jpg\",\"https://steemitimages.com/DQmQCpyhKUqkGcad2p25XUhwmGmn66C5ySzvjWR2CVVPwJZ/strut%20not%20opmitized.jpg\",\"https://steemitimages.com/DQme8LukjcVqh66tdcwBBcjKwSYc2aQyT5Te1xVY9MQvPiy/img6.jpg\",\"https://steemitimages.com/DQmbnB8vZuhVvExn9kgtJ2Vwo2qt8FWWFoGcXgokmibYeo3/img7.jpg\",\"https://steemitimages.com/DQmSZdGNY6feyJMtFS3WdALk6fzBqsV9DAi6hRCxbq63CgP/img8.jpg\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "c9180d28796fa719461943dc72f2bedaaf5a8f8b",
  "block": 15428543,
  "trx_in_block": 5,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-09-13T10:55:57",
  "op": [
    "custom_json",
    {
      "required_auths": [],
      "required_posting_auths": [
        "debuglove"
      ],
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"debuglove\",\"following\":\"new-game-coin\",\"what\":[\"blog\"]}]"
    }
  ]
}

{
  "trx_id": "4f24eda05bf17c65438291a2ac5c1770601df354",
  "block": 15428474,
  "trx_in_block": 28,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-09-13T10:52:30",
  "op": [
    "custom_json",
    {
      "required_auths": [],
      "required_posting_auths": [
        "debuglove"
      ],
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"debuglove\",\"following\":\"charmand3r\",\"what\":[\"blog\"]}]"
    }
  ]
}

{
  "trx_id": "c6e2c082a6a9c23b29e0e5ff91d41a42bc2747bc",
  "block": 15428464,
  "trx_in_block": 19,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-09-13T10:52:00",
  "op": [
    "custom_json",
    {
      "required_auths": [],
      "required_posting_auths": [
        "debuglove"
      ],
      "id": "follow",
      "json": "[\"follow\",{\"follower\":\"debuglove\",\"following\":\"aheart\",\"what\":[\"blog\"]}]"
    }
  ]
}

{
  "trx_id": "bf12685ae8317f040b85a1415579e6f47017fa53",
  "block": 15428454,
  "trx_in_block": 24,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-09-13T10:51:30",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "aheart",
      "permlink": "i-hulk-5-min-drawing-caricature",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "484a21a963252b1b89e3c0c62c41352c6be4ddac",
  "block": 15059701,
  "trx_in_block": 0,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-08-31T15:24:30",
  "op": [
    "vote",
    {
      "voter": "fractalnode",
      "author": "debuglove",
      "permlink": "strings-in-c",
      "weight": 5000
    }
  ]
}

{
  "trx_id": "19239d48d114388b8cd3e34ddafcb8e931bbcc1b",
  "block": 15059054,
  "trx_in_block": 1,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-08-31T14:52:09",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "themoneygps",
      "permlink": "hqlvb6h2",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "b3b28ec2f1b3bdc35c4e898697b692d8b4ceda3b",
  "block": 15058763,
  "trx_in_block": 20,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-08-31T14:37:33",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "string",
      "author": "debuglove",
      "permlink": "strings-in-c",
      "title": "Strings in C",
      "body": "@@ -6285,17 +6285,17 @@\n library%0A\n-%09\n+%0A\n string.h\n",
      "json_metadata": "{\"tags\":[\"string\",\"in\",\"c\"],\"image\":[\"https://steemitimages.com/DQmU1thbsVHXaA7nAZW2JPr5R7C3ARU3GP6bHFEoFipRzyi/img1.jpg\",\"https://steemitimages.com/DQmYcTEdY1xpvMF4ZyuLwMKZtP6bbNs2xPStgzEtbCNhNJE/img2.jpg\",\"https://steemitimages.com/DQmVfVChsVZPLA4jembBsa6hKu5op8ahuN9drJStM35sHrD/img3.jpg\",\"https://steemitimages.com/DQmQ3YuAgy6KSiCtQqEL2uEkeL1pwdqWSH67owf77hn9yVt/img4.jpg\",\"https://steemitimages.com/DQmRpkWqzdj1YoU5A9DDjd47S5UFgk7V5cdhgQLTzh9ZYrV/img5.jpg\",\"https://steemitimages.com/DQmaRvqRcBCNgiQyUatyUpEtFCRQswfcyDxpyU2hqhDQJkF/img6.jpg\",\"https://steemitimages.com/DQmTFNZXovwLREkHTKGzB9tzPqX8BRbfcCjhj6GLR9JmAfG/img7.jpg\",\"https://steemitimages.com/DQmRe4SptxnRpM1X3hGErvALTMqDN2up1FZdY8xGDzNtwAA/img8.jpg\",\"https://steemitimages.com/DQmWijGwYZWJDF6ssYNDSDriZGdHDyqfZMzZy18DUpkksyF/img9.jpg\",\"https://steemitimages.com/DQmfXNWEcTLoFshbpqBnPf9bBpyEjg8BgVtdyyi7FvHBMxG/img10.jpg\",\"https://steemitimages.com/DQmahMmzSzG7bbmdGCzDjCj4vtwaJUzUxhzC5qory3QMCMw/img11.jpg\",\"https://steemitimages.com/DQmT1kRktBYTzSq8zhJJoC8CbnhiMRcntHkRvkS3KjiX9B7/img12.jpg\",\"https://steemitimages.com/DQmVbTt3YWXVCRF78waEicvmuDzZY8g56UcLNVtMPUQnK8m/img13.jpg\",\"https://steemitimages.com/DQmPhWFvzbh1yN46pGwuaDQPDwg69B99dc6GKbvqH5sUXfW/img14.jpg\",\"https://steemitimages.com/DQmSmmPukT2NBWFmB6Jr1gKwCyhwGNcuhdawKkRDUwVRKmy/img15.jpg\",\"https://steemitimages.com/DQmapS4ouM3uZt5pn37kVNxu6HgyzCRDU5pMe9tE8pZtMK2/img16.jpg\",\"https://steemitimages.com/DQmZnzqHzopfUyQaHAf2K1sb7bG55rLocVMdqgYMSsmMNjo/img17.jpg\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "8ca7baf84036bf0aed17738cde9f5471f7eda6c3",
  "block": 15058653,
  "trx_in_block": 29,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-08-31T14:32:00",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "string",
      "author": "debuglove",
      "permlink": "strings-in-c",
      "title": "Strings in C",
      "body": "@@ -2722,34 +2722,32 @@\n --%0A%0A%3E char word%5B\n-50\n %5D = %22%22;%0A%0A%3Eprintf\n",
      "json_metadata": "{\"tags\":[\"string\",\"in\",\"c\"],\"image\":[\"https://steemitimages.com/DQmU1thbsVHXaA7nAZW2JPr5R7C3ARU3GP6bHFEoFipRzyi/img1.jpg\",\"https://steemitimages.com/DQmYcTEdY1xpvMF4ZyuLwMKZtP6bbNs2xPStgzEtbCNhNJE/img2.jpg\",\"https://steemitimages.com/DQmVfVChsVZPLA4jembBsa6hKu5op8ahuN9drJStM35sHrD/img3.jpg\",\"https://steemitimages.com/DQmQ3YuAgy6KSiCtQqEL2uEkeL1pwdqWSH67owf77hn9yVt/img4.jpg\",\"https://steemitimages.com/DQmRpkWqzdj1YoU5A9DDjd47S5UFgk7V5cdhgQLTzh9ZYrV/img5.jpg\",\"https://steemitimages.com/DQmaRvqRcBCNgiQyUatyUpEtFCRQswfcyDxpyU2hqhDQJkF/img6.jpg\",\"https://steemitimages.com/DQmTFNZXovwLREkHTKGzB9tzPqX8BRbfcCjhj6GLR9JmAfG/img7.jpg\",\"https://steemitimages.com/DQmRe4SptxnRpM1X3hGErvALTMqDN2up1FZdY8xGDzNtwAA/img8.jpg\",\"https://steemitimages.com/DQmWijGwYZWJDF6ssYNDSDriZGdHDyqfZMzZy18DUpkksyF/img9.jpg\",\"https://steemitimages.com/DQmfXNWEcTLoFshbpqBnPf9bBpyEjg8BgVtdyyi7FvHBMxG/img10.jpg\",\"https://steemitimages.com/DQmahMmzSzG7bbmdGCzDjCj4vtwaJUzUxhzC5qory3QMCMw/img11.jpg\",\"https://steemitimages.com/DQmT1kRktBYTzSq8zhJJoC8CbnhiMRcntHkRvkS3KjiX9B7/img12.jpg\",\"https://steemitimages.com/DQmVbTt3YWXVCRF78waEicvmuDzZY8g56UcLNVtMPUQnK8m/img13.jpg\",\"https://steemitimages.com/DQmPhWFvzbh1yN46pGwuaDQPDwg69B99dc6GKbvqH5sUXfW/img14.jpg\",\"https://steemitimages.com/DQmSmmPukT2NBWFmB6Jr1gKwCyhwGNcuhdawKkRDUwVRKmy/img15.jpg\",\"https://steemitimages.com/DQmapS4ouM3uZt5pn37kVNxu6HgyzCRDU5pMe9tE8pZtMK2/img16.jpg\",\"https://steemitimages.com/DQmZnzqHzopfUyQaHAf2K1sb7bG55rLocVMdqgYMSsmMNjo/img17.jpg\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "b9126b42f5c4c0dbb4562faef0c2a3de46c1e357",
  "block": 15058595,
  "trx_in_block": 11,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-08-31T14:29:06",
  "op": [
    "comment",
    {
      "parent_author": "",
      "parent_permlink": "string",
      "author": "debuglove",
      "permlink": "strings-in-c",
      "title": "Strings in C",
      "body": "As we saw in the lasth thread, strings are stored in arrays of chars in C programming language. It is also possible to store them as string literals, but those are immutable, unlike arrays. The characters in strings are stored in sequence followed by a NUL byte (\\0) which terminates it. The C library which allows us to do string manipulation is the \"string.h\" library working together with \"stdio.h\" library and its I/O operations \n\n\n\n## String length\n\nIn last thread when we declared strings, we declared the arrays containing its size was declared automatically, but when you declare its size, you must take in consideration its NUL byte:\n\n---\n>\tchar word[8] = {'m','e','s','s','a','g','e',0};\n\n---\n\nYou may also have some flexibility in strings declaration, like you do in arrays:\n\n---\n\n>char word[] = \"hello\\0\";\n\tchar word[6] = \"hello\\0\";\n\tchar word[6] = = {'h','e','l','l','o',0};\n\n---\n\nWe must pay attention with the size in declaration. What if the declaration contains an incorrect size, choping a character or even more than one when you declare the size? Well, if you chop the last character, the compiler will not know exactly where the string ends, so it will print a lot of dirty values, probably in most cases, not initialized values. I write this observation because it happens very often, since when declaring the size of an array, doing it with a value below, accounting for the position 0. But you may also chop a character of the string itself. Lets see what happens: \n\n ---\n\n>char word[4] = \"hello\\0\";\n\n---\n\n\n![img1.jpg](https://steemitimages.com/DQmU1thbsVHXaA7nAZW2JPr5R7C3ARU3GP6bHFEoFipRzyi/img1.jpg)\n\n\nSee how much dirty value? Thats why i prefer declaring the size automatically with the [] notation. Lets declare the size correctly, and correct the errors and dirty values: \n\n---\n\n>char word[6] = \"hello\\0\";\n\tprintf(\"%s\\n\", word);\n\treturn 0;\n\n---\n\n![img2.jpg](https://steemitimages.com/DQmYcTEdY1xpvMF4ZyuLwMKZtP6bbNs2xPStgzEtbCNhNJE/img2.jpg)\n\nWe may also initialize strings with our old friends, pointers: \n\n---\n\n>char *word = \"hello\";\n\tprintf(\"%s\\n\", word);\n\n---\n\nThis declaration already take into account the NUL byte, and you do not have to worry about the size neither.\n\n\n## stdio.h string related functions\n\n\t\n### gets()\nThe gets function will take a string  input from the standard input stream and store into a string container you specify, like an array, most commonly. It will capture your string until a new line \\n is found, generally from the ENTER key when you finish input, but it also captures it when you reach an end of file. Its prototype is:\n\n---\n\n>char *gets(char *str);\n\n---\n\n\nYou must be careful trying to declare gets() automatically.Lets check the example below:\n\n---\n\n> char word[50] = \"\";\n\n>printf(\"Enter input : \");\n>gets(word);\n\n>printf(\"%s\", word);\n\n---\n\nIn this example, some may think we are declaring the array size automatically. Indeed, at the declaration we are, however, it cannot be resized by the gets function later. So, unless you input nothing at your console, we will then get an reassignment and overflow. We must initialize the size then:\n\n---\n\n\n> char word[50] = \"\";\n\n>printf(\"Enter input : \");\n>gets(word);\n\n>printf(\"%s\\n\", word);\n\n---\n\t\n![img3.jpg](https://steemitimages.com/DQmVfVChsVZPLA4jembBsa6hKu5op8ahuN9drJStM35sHrD/img3.jpg)\n\n\nYou must also take into account the size of the input. If you declare an input too low, and type a huge string, we will face the same overflow problem. We can solve this with dinamically allocating a memory size at runtime as we will see in later tutorials. Then you can solve problems like array sizes being declared dinamically as your program is runnning. Stay tuned :D\n\n\n\n\n### fgets()\n\n\nfgets() looks a lot like gets() function. It is a little safer, since you must pass the buffer size in its declaration, but you may still pass as an argument a size higher than string storage size. Here its is its prototype:\n\n---\n\n>char *fgets(char *str, int n, FILE *stream);\n\n---\n\nThe first argument is the string like we did with gets(). The second is the size of the buffer the function will read. Anything you type after that size will be ignored. The third parameter is the file stream. Our applications can have many file streams, and you can even declare your own file streams to point to a file or network connection and such, however, by default, we will work with the 3 default streams from any application, stdin, stdout and stderr. stdin is our input stream, stdout is the output stream and stderr is the error stream. You can do all sorts of thing including redirect them one to another as you wish. Lets see an example getting a string from the stdin input then printing it to the screen.:\n\n---\n\t\n>char word[5] = \"\";\n\n>printf(\"Enter input : \");\n>fgets(word, 5, stdin);\n\n>printf(\"%s\\n\", word);\n\n---\n\n![img4.jpg](https://steemitimages.com/DQmQ3YuAgy6KSiCtQqEL2uEkeL1pwdqWSH67owf77hn9yVt/img4.jpg)\n\n\nLike we said, you must be carefull to pass as argument a size compatible with the string storage size. If we declare a size bigger than the storage, overflow can still happen:\n\n---\n\n>char word[5] = \"\";\n\n>printf(\"Enter input : \");\n>fgets(word, 10, stdin);\n\n>printf(\"%s\\n\", word);\n\n---\n\n### puts()\nputs looks a lot like the printf() function. It will print a string to stdout filestream, but unlike printf(), it will append a new line \\n character for you. Its prototype is: \n\n---\n\n>int puts(const char *str);\n\n---\n\nNow with an example:\n\n---\n\n>char word[] = \"hello puts\";\n\tputs(word);\n\treturn 0;\n\n---\n\n![img5.jpg](https://steemitimages.com/DQmRpkWqzdj1YoU5A9DDjd47S5UFgk7V5cdhgQLTzh9ZYrV/img5.jpg)\n\n### fputs() \nfputs() works like puts(), but you can redirect the stream to one of your choice, like a txt file. Then you can type into your console application to a text file directly. But lets see a simpler example, just redirecting to stderr stream instead of stdout from puts:\n\n---\n\n>char word[] = \"hello puts\";\n\tfputs(word, stderr);\n\treturn 0;\n\t\n---\n\nfputs will not append a \\n at end of your string. So, you may append it at your string declaration if you would like:\n\n---\n\n>char word[] = \"hello puts\\n\";\n\tfputs(word, stderr);\n\treturn 0;\n\n\n---\n\n![img6.jpg](https://steemitimages.com/DQmaRvqRcBCNgiQyUatyUpEtFCRQswfcyDxpyU2hqhDQJkF/img6.jpg)\n\n## functions of string.h library\n\tstring.h is the default string libray for C. It allows us to manipulate strings directly with its functions. Lets see the most important functions of this library.\n\n###strcpy() \nstrcpy will copy a string into another overwriting whatever is inside the destination string. If your destination string is bigger than the source, the NUL byte will be copied and inform the returned value the end of the string, so it will erase the the rest of the characters from your original string. The destination string must be a datatype that can be modified, like a pointer or array.  Here is its prototype:\n\n---\n\n>char *strcpy(char *dst, char *src);\n\n---\n\nIts implementation is simple, but be careful not trying to copy a bigger string into a smaller one:\n\n---\n\n>char word[] = \"hello\\0\";\n\tchar word2[] = \"am\\0\";\n\n>printf(\"%s\\n\", word);\n\n>strcpy(word, word2);\n\tprintf(\"%s\\n\", word);\n\n>return 0;\n\n\n---\n\n![img7.jpg](https://steemitimages.com/DQmTFNZXovwLREkHTKGzB9tzPqX8BRbfcCjhj6GLR9JmAfG/img7.jpg)\n\nThis is one of the functions which is a source of problems, like described in \"Secure Coding in C and C++\" by robert C. Seacord. You must always make sure the destination string is larger than the source, because if your source string is larger, it will overflow its values through the string overwriting whatever is stored in the memory beyond the destination string. You could even overflow until you find a breach then pass a C command inside this same string sending an instruction the program will comprenhend and execute. strcpy will return a value, which is pointer to the destination string. Here is the same code, but passing strcpy directly to printf to show it pointing to the destination string:\n\n---\n\t\n>char word[] = \"hello\\0\";\n\tchar word2[] = \"am\\0\";\n\n>printf(\"%s\\n\", word);\t\n\tprintf(\"%s\\n\", strcpy(word, word2));\n\n---\n\nIf you dont want to worry about the string size, you can then declare your array with a size capable of containing the operation. Even tough you might waste a little more space, it is safer than risking an overflow: \n\n---\n\n>char word[] = \"hello\\0\";\n\tchar word2[25] = \"am\\0\";\n\n>printf(\"%s\\n\", word);\n\n>strcpy(word2, word);\n\tprintf(\"%s\\n\", word);\t\n\n---\n\n### strcat() \n\nstrcat will concatenate a destination string into a source string: \n\n---\n\n>char *strcat(char *dst, char const *src);\n\n---\n\nstrcat also has the same problem of a possible overflow. You must ensure the destination string can be concatenated and not overwrite another memory adress. So now you have 2 or more strings to evaluate size, the sources and the destination. strcat(), like strcpy() will also return a pointer to the destination operation performed by the function:\n\n---\n\n>char word[10] = \"hello\\0\";\n\tchar word2[3] = \"am\\0\";\n\n>printf(\"%s\\n\", word);\n\t\n>printf(\"%s\\n\", strcat(word, word2));\n\n\n---\n\n![img8.jpg](https://steemitimages.com/DQmRe4SptxnRpM1X3hGErvALTMqDN2up1FZdY8xGDzNtwAA/img8.jpg)\n\n\nAn incorrect size, would generate an oveflow when you concatenate and try to store it into a small container:\n\n---\n\n>char word[7] = \"hello\\0\";\n\tchar word2[3] = \"am\\0\";\n\n>printf(\"%s\\n\", word);\n\t\n>printf(\"%s\\n\", strcat(word, word2));\n\n>return 0;\n\n---\n\n### strlen\n we can get a return of the string size through strlen() function. Here is its prototype:\n\n---\n\n>strlen(str);\n\n---\n\n\nThis is the most simple function of the library:\t\n---\n\n>char str[] = \"Hello World\";\n>printf(\"%d\\n\", strlen(str));\n\n---\n\n![img9.jpg](https://steemitimages.com/DQmWijGwYZWJDF6ssYNDSDriZGdHDyqfZMzZy18DUpkksyF/img9.jpg)\n\n### strcmp()\nwe can compare if 2 strings have the same content by using strcmp(). Since the == operator will not work with strings, we use that function passing as arguments 2 strings to be compared:\n\n---\n\n>int strcmp(char *s1, char *s2);\n\n---\n\nIf they are equal, strcmp() will return 0, if the first string is greater than the second string it will return a value greater than 0, and returns less than 0 is the first string is less than the second. Not very intuitive since many will write:\n\n---\n\n>strcmp(a, b)\n\n---\n\nand expect true if they are equal. strcmp() offers no dangers of overflowing the array, as long as your string is terminated wil a NUL byte(0).\n\n### Restricting the size of string functions and avoiding overflow \n\nstrcpy, strcat and strcmp also have a  version which perform the very same functionality, except for the reason they receive a length argument to to limit the characters can be copied into another or compared. \n\n\n### strncpy()\n\nstrncpy() is the sized version of strcpy() function. Its prototype is:\n\n---\n\n\tchar *strncpy(char *dst, char const *src, size);\n\n---\n\nThis function will copy characters from the source to destination and fills it overwriting the  destination string until it reaches the exact size of the last parameter, the size. If the size argument  is bigger than the destination string container size, an overflow will occur(carefull with automatic inicialization!). We must pay attention for the size parameter. Make sure the datatype containing the string is big enough to hold the result of the operation:\n\n---\n\n>char str1[50] = \"hellows\";\n\tchar str2[50] = \"my application\";\n\n>printf(\"%s\\n\", strncpy(str1, str2, 5));\n\n---\n\n![img10.jpg](https://steemitimages.com/DQmfXNWEcTLoFshbpqBnPf9bBpyEjg8BgVtdyyi7FvHBMxG/img10.jpg)\n\n### strncat() \n\nstrncat unlike strncpy will always append the NUL byte at the final string, so it will append the source string to the destination and also the NUL byte. It works like the strcat function, but you must specify the size. Its prototype is: \n\n---\n\n>char *strncat(char *dest, const char *src, size);\n\n---\n\nThe function will concantenate until the size you pass as argument:\n\n---\n\n>char str1[50] = \"hello\";\n\tchar str2[50] = \" my application\";\n\n>strncat(str1, str2, 7);\n\n>printf(\"%s\\n\", str1);\n\n---\n\n![img11.jpg](https://steemitimages.com/DQmahMmzSzG7bbmdGCzDjCj4vtwaJUzUxhzC5qory3QMCMw/img11.jpg)\n\n### strncmp() \n\nstrncmp() will compare two strings up to the size you passed as argument to the function. If they are different after the the size but equal until the size, the function will return 0 like strcmp and a value greater than 0 if the first string is greater than second, less than 0 if the first string is less than the second just like strcmp():\n\n---\n\n>char strncmp(char const *s1, char const *s2, size);\n\n---\n\nLets see an example in this case, since it can be a little more sifficult than strcmp():\n\n---\n\n>char str1[50] = \"hello my app\";\n\tchar str2[50] = \"hello world\";\n\n>printf(\"%d\\n\", strncmp(str1, str2, 5));\n\n---\n\n![img12.jpg](https://steemitimages.com/DQmT1kRktBYTzSq8zhJJoC8CbnhiMRcntHkRvkS3KjiX9B7/img12.jpg)\n\n\nNote how our function returns 0 as if the 2 strings were equal. They are indeed until the size, but lets increase the size of this comparation to see what happens:\n\n---\n\n>char str1[50] = \"hello my app\";\n\tchar str2[50] = \"hello world\";\n\n>printf(\"%d\\n\", strncmp(str1, str2, 10));\n\t\n>return 0;\n\n---\n\n![img13.jpg](https://steemitimages.com/DQmVbTt3YWXVCRF78waEicvmuDzZY8g56UcLNVtMPUQnK8m/img13.jpg)\n\nThere. Now we have a result of -1, since \"m\" is lesses than \"w\", the first character they differ.\n\n\n## Working with substrings\n\n### strstr() \nstrstr will receive 2 parameters, the first is the string to perform the search, and the second is the character you must find.\tIt will then return a substring from this first string, starting with the first occurrence found in the string, until the end of the string, if found. Its prototype is:\n\n---\n\n>char *strstr(const char *str1, const char *str2);\n\n---\n\nLets extract a substring then:\n\n---\n\n>const char str1[50] = \"Hellow substring\";\n\tconst char str2[50] = \"o\";\t\n\n>printf(\"Extracting substring from str1: %s\\n\", strstr(str1, str2));\n\t\n>return 0;\n\n---\n\n![img14.jpg](https://steemitimages.com/DQmPhWFvzbh1yN46pGwuaDQPDwg69B99dc6GKbvqH5sUXfW/img14.jpg)\n\nWe can see how the function performs a search in str1, until it finds the first occurrence of the pattern in str2. It will then return the substring left after the first occurrence which can be stored in a variable. If the function finds nothing, it will just return null.\n\n\n### strchr() \n\nIf you must find only a character position, the function strchr() will receive a string and a integer as arguments(the integer contains a character value however), and perform the search for you to find its position, returning the the pointer to the string plus the positon the first occurrence of the character is found. If it finds the first occurrence at position 4, it will take the pointer to the string, performs a pointer arithmetic adding 4 and read from there. If the function cannot find the character in the specified string, it will return a NULL pointer. The search is case sensitive. That means the function will make distinction betwen upper case and lower case characters:\n\n---\n\n>char word[20] = \"Rat return to race\";\n>char *returned_value = strchr(word, 'r');\n>char *noreturn = strchr(word, 'p');\n\n>printf(\"strchr returned: %s\\n\", returned_value);\n>printf(\"strchr returned: %s\\n\", noreturn);\n>return 0;\n\n---\n\n![img15.jpg](https://steemitimages.com/DQmSmmPukT2NBWFmB6Jr1gKwCyhwGNcuhdawKkRDUwVRKmy/img15.jpg)\n\n\n### strrchr() \n\nstrrchr works much like strchr(), expet it will begin the reading process from the ending of the string. It will find the first position and read from there also: \n\n---\n\n>char word[20] = \"Rat return to race\";\n\tchar *returned_value = strrchr(word, 'r');\n>char *noreturn = strrchr(word, 'p');\n\n>printf(\"strchr returned: %s\\n\", returned_value);\n\tprintf(\"strchr returned: %s\\n\", noreturn);\n\treturn 0;\n\n---\n\n![img16.jpg](https://steemitimages.com/DQmapS4ouM3uZt5pn37kVNxu6HgyzCRDU5pMe9tE8pZtMK2/img16.jpg)\n\n\n### strstr() \nstrstr() will find a substring, much like any high level programming language. We will pass as the second argument the substring we would like to find and not a character anymore. strstr() will force you to work with double quotes and also return NULL if the substring is not found:\n\n---\n\n>char word[20] = \"Rat return to race\";\n\tchar *returned_value = strstr(word, \"turn\");\n\tchar *noreturn = strstr(word, \"p\");\n\n>printf(\"strchr returned: %s\\n\", returned_value);\n\tprintf(\"strchr returned: %s\\n\", noreturn);\n\treturn 0;\n\n---\n\n\n![img17.jpg](https://steemitimages.com/DQmZnzqHzopfUyQaHAf2K1sb7bG55rLocVMdqgYMSsmMNjo/img17.jpg)\n\n\nThe most basic string functions in C have been covered. In programming languages like perl, which has one of its main strenghts string manipulation, you can do all those functions and more, sometimes with less work. Neverthless, its very productive to learn how these functions work in C, to perform fast and adaptable string manipulation. Also, you will find very often while you are debugging in assembly level these functions, since the OS will implement exactly like C does.",
      "json_metadata": "{\"tags\":[\"string\",\"in\",\"c\"],\"image\":[\"https://steemitimages.com/DQmU1thbsVHXaA7nAZW2JPr5R7C3ARU3GP6bHFEoFipRzyi/img1.jpg\",\"https://steemitimages.com/DQmYcTEdY1xpvMF4ZyuLwMKZtP6bbNs2xPStgzEtbCNhNJE/img2.jpg\",\"https://steemitimages.com/DQmVfVChsVZPLA4jembBsa6hKu5op8ahuN9drJStM35sHrD/img3.jpg\",\"https://steemitimages.com/DQmQ3YuAgy6KSiCtQqEL2uEkeL1pwdqWSH67owf77hn9yVt/img4.jpg\",\"https://steemitimages.com/DQmRpkWqzdj1YoU5A9DDjd47S5UFgk7V5cdhgQLTzh9ZYrV/img5.jpg\",\"https://steemitimages.com/DQmaRvqRcBCNgiQyUatyUpEtFCRQswfcyDxpyU2hqhDQJkF/img6.jpg\",\"https://steemitimages.com/DQmTFNZXovwLREkHTKGzB9tzPqX8BRbfcCjhj6GLR9JmAfG/img7.jpg\",\"https://steemitimages.com/DQmRe4SptxnRpM1X3hGErvALTMqDN2up1FZdY8xGDzNtwAA/img8.jpg\",\"https://steemitimages.com/DQmWijGwYZWJDF6ssYNDSDriZGdHDyqfZMzZy18DUpkksyF/img9.jpg\",\"https://steemitimages.com/DQmfXNWEcTLoFshbpqBnPf9bBpyEjg8BgVtdyyi7FvHBMxG/img10.jpg\",\"https://steemitimages.com/DQmahMmzSzG7bbmdGCzDjCj4vtwaJUzUxhzC5qory3QMCMw/img11.jpg\",\"https://steemitimages.com/DQmT1kRktBYTzSq8zhJJoC8CbnhiMRcntHkRvkS3KjiX9B7/img12.jpg\",\"https://steemitimages.com/DQmVbTt3YWXVCRF78waEicvmuDzZY8g56UcLNVtMPUQnK8m/img13.jpg\",\"https://steemitimages.com/DQmPhWFvzbh1yN46pGwuaDQPDwg69B99dc6GKbvqH5sUXfW/img14.jpg\",\"https://steemitimages.com/DQmSmmPukT2NBWFmB6Jr1gKwCyhwGNcuhdawKkRDUwVRKmy/img15.jpg\",\"https://steemitimages.com/DQmapS4ouM3uZt5pn37kVNxu6HgyzCRDU5pMe9tE8pZtMK2/img16.jpg\",\"https://steemitimages.com/DQmZnzqHzopfUyQaHAf2K1sb7bG55rLocVMdqgYMSsmMNjo/img17.jpg\"],\"app\":\"steemit/0.1\",\"format\":\"markdown\"}"
    }
  ]
}

{
  "trx_id": "d61424ceb465765f1055bae00a833483d31976e1",
  "block": 14960455,
  "trx_in_block": 7,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-08-28T04:36:30",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "themoneygps",
      "permlink": "o3lygeyj",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "b53b2d3dce6a904455e766b8bf6191087f43b444",
  "block": 14907373,
  "trx_in_block": 17,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-08-26T08:21:54",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "themoneygps",
      "permlink": "5emyap3q",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "82593965543f358c1e78c488f3ca722eb6cd1c96",
  "block": 14879439,
  "trx_in_block": 19,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-08-25T09:04:30",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "themoneygps",
      "permlink": "urjds1fh",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "b66cf355a13d08e36928c4944a325525d1bdeffa",
  "block": 14818881,
  "trx_in_block": 14,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-08-23T06:34:42",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "themoneygps",
      "permlink": "akmojofl",
      "weight": 10000
    }
  ]
}

{
  "trx_id": "e0ed59cb90a4ef4205178bd68771456522d29fe5",
  "block": 14801833,
  "trx_in_block": 22,
  "op_in_trx": 0,
  "virtual_op": 0,
  "timestamp": "2017-08-22T16:22:15",
  "op": [
    "vote",
    {
      "voter": "debuglove",
      "author": "themoneygps",
      "permlink": "vlnr8hu2",
      "weight": 10000
    }
  ]
}