{"id":16897,"date":"2023-06-27T06:54:05","date_gmt":"2023-06-27T06:54:05","guid":{"rendered":"https:\/\/www.prepbytes.com\/blog\/?p=16897"},"modified":"2023-06-27T06:54:05","modified_gmt":"2023-06-27T06:54:05","slug":"basic-block-in-compiler-design","status":"publish","type":"post","link":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/","title":{"rendered":"Basic Block In Compiler Design"},"content":{"rendered":"

\"\"<\/p>\n

A Basic Block refers to a linear sequence of code statements that lacks any internal branching, except at its start and end. It represents a set of instructions that are executed sequentially without interruption.<\/p>\n

During the compilation process, the source code of a programming language is initially transformed into an intermediate code. This intermediate code is subsequently divided into basic blocks. Once the intermediate code is partitioned into basic blocks, the flow of execution between these blocks is depicted using a flow graph.<\/p>\n

What is the Basic Block in Compiler Design?<\/h2>\n

In the realm of compiler design, a basic block refers to a section of code that follows a linear path, featuring a single entry point and a single exit point. The construction of basic blocks entails dividing a program’s control flow graph into these distinct blocks.<\/p>\n

The objective at hand is to partition a series of three-address codes into basic blocks. The formation of a new basic block always commences with the first instruction and extends to include subsequent instructions until encountering a jump or a label. In the absence of jumps or labels, control flows sequentially from one instruction to the next.<\/p>\n

Algorithm of Basic Block in Compiler Design<\/h3>\n

To begin with, identify the set of leaders within the intermediate code, which refers to the initial statements of basic blocks. The process of locating these leaders can be accomplished by following these steps:<\/p>\n

    \n
  1. The first instruction in the three-address code is considered a leader.<\/li>\n
  2. Instructions that serve as targets for conditional or unconditional goto statements are also regarded as leaders.<\/li>\n
  3. Instructions that immediately follow any conditional, unconditional, or jump statements are recognized as leaders.<\/li>\n
  4. For each identified leader, its corresponding basic block encompasses the leader itself and all instructions up until the next leader.<\/li>\n<\/ol>\n

    Example of Basic Block in Compiler Design<\/h3>\n

    Consider the source code for converting a 10 x 10 matrix to an identity matrix.<\/p>\n

    for r from 1 to 10 do\n      for c from 1 to 10 do\n             a [ r, c ] = 0.0;\n\nfor r from 1 to 10 do\n         a [ r, c ] = 1.0;<\/code><\/pre>\n
    The following are the three address codes for the above source code:<\/p>\n
     1) r = 1\n 2) c = 1\n 3) t1 = 10 * r\n 4) t2 = t1 + c\n 5) t3 = 8 * t2\n 6) t4 = t3 - 88\n 7) a[t4] = 0.0\n 8) c = c + 1\n 9) if c <= 10 goto (3)\n 10) r = r + 1\n 11) if r <= 10 goto (2)\n 12) r = 1\n 13) t5 = c - 1\n 14) t6 = 88 * t5\n 15) a[t6] = 1.0\n 16) r = r + 1\n 17) if r <= 10 goto (13)<\/code><\/pre>\n
    There are six basic blocks for the above-given code, which are:<\/p>\n
    B1 for statement 1\nB2 for statement 2\nB3 for statements 3-9\nB4 for statements 10-11\nB5 for statement 12\nB6 for statements 13-17.<\/code><\/pre>\n
    Explanation<\/strong>
    \nBased on the leaders' definition provided in the algorithm above:<\/p>\n
      \n
    • Instruction 1 qualifies as a leader since it corresponds to the first instruction in the three-address code.<\/li>\n
    • Instruction 2 is classified as a leader because it is immediately followed by a goto statement at Instruction 11.<\/li>\n
    • Both Instruction 3 and Instruction 13 are considered leaders since they are followed by a goto statement at Instruction 9 and 17, respectively.<\/li>\n
    • Instruction 10 and Instruction 12 also function as leaders because they are succeeded by a conditional goto statement at Instruction 9 and 17, respectively.<\/li>\n<\/ul>\n
      Conclusion<\/strong>
      \nIn compiler design, a basic block is a consecutive sequence of code statements that have a single entry point and a single exit point. Basic block construction involves dividing a program's control flow graph into these blocks. The formation of basic blocks is essential for various compiler optimization techniques and code generation.<\/p>\n
      Frequently Asked Questions (FAQs) related to Basic Block in Compiler Design:<\/h2>\n
      Q1. Why are basic blocks important in compiler design?<\/strong>
      \nBasic blocks provide a structured representation of a program's control flow, making it easier for compilers to analyze and optimize code. They enable efficient code generation, register allocation, loop optimizations, and control flow analysis.<\/p>\n
      Q2. How are basic blocks identified in the intermediate code?<\/strong>
      \nBasic blocks are identified by finding the leaders within the intermediate code. Leaders are determined based on specific conditions, such as being the first instruction, being a target of goto statements, or following conditional\/unconditional jumps.<\/p>\n
      Q3. What is the significance of leaders in basic block construction?<\/strong>
      \nLeaders act as starting points for constructing basic blocks. Each leader indicates the beginning of a new basic block, and the block continues until the next leader is encountered. Leaders help partition the code into meaningful units for further analysis and optimization.<\/p>\n
      Q4. Can a basic block have multiple entry points or exit points?<\/strong>
      \nNo, a basic block in compiler design is defined to have a single entry point and a single exit point. This ensures a clear and well-defined control flow within each block.<\/p>\n
      Q5. How are basic blocks represented in the control flow graph?<\/strong>
      \nBasic blocks are depicted as nodes in the control flow graph, where the edges between nodes represent the flow of control between basic blocks. The control flow graph provides a visual representation of the program's structure and facilitates analysis and optimization.<\/p>\n
      Q6. What is the role of basic blocks in optimization?<\/strong>
      \nBasic blocks serve as units for applying various compiler optimizations, such as constant folding, dead code elimination, common subexpression elimination, and loop optimizations. By working on individual basic blocks, compilers can apply targeted optimizations to improve code efficiency.<\/p>\n
      Q7. Can basic blocks overlap in a program?<\/strong>
      \nNo, basic blocks cannot overlap in a program. Each basic block represents a distinct and non-overlapping portion of code with a single entry and exit point.<\/p>\n
      Q8. How are basic blocks useful in code generation?<\/strong>
      \nBasic blocks provide a structured representation of code, allowing compilers to generate efficient and optimized machine code. The code generation phase typically operates on basic blocks, transforming them into appropriate assembly or machine instructions.<\/p>\n","protected":false},"excerpt":{"rendered":"
      A Basic Block refers to a linear sequence of code statements that lacks any internal branching, except at its start and end. It represents a set of instructions that are executed sequentially without interruption. During the compilation process, the source code of a programming language is initially transformed into an intermediate code. This intermediate code […]<\/p>\n","protected":false},"author":52,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"footnotes":""},"categories":[165],"tags":[],"class_list":["post-16897","post","type-post","status-publish","format-standard","hentry","category-cs-subjects"],"yoast_head":"\nBasic Block In Compiler Design<\/title>\n<meta name=\"description\" content=\"A Basic Block refers to a linear sequence of code statements that lacks any internal branching, except at its start and end.\" \/>\n<meta name=\"robots\" content=\"index, follow, max-snippet:-1, max-image-preview:large, max-video-preview:-1\" \/>\n<link rel=\"canonical\" href=\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/\" \/>\n<meta property=\"og:locale\" content=\"en_US\" \/>\n<meta property=\"og:type\" content=\"article\" \/>\n<meta property=\"og:title\" content=\"Basic Block In Compiler Design\" \/>\n<meta property=\"og:description\" content=\"A Basic Block refers to a linear sequence of code statements that lacks any internal branching, except at its start and end.\" \/>\n<meta property=\"og:url\" content=\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/\" \/>\n<meta property=\"og:site_name\" content=\"PrepBytes Blog\" \/>\n<meta property=\"article:publisher\" content=\"https:\/\/www.facebook.com\/prepbytes0211\/\" \/>\n<meta property=\"article:published_time\" content=\"2023-06-27T06:54:05+00:00\" \/>\n<meta property=\"og:image\" content=\"https:\/\/prepbytes-misc-images.s3.ap-south-1.amazonaws.com\/assets\/1687848482540-Basic%20Block%20In%20Compiler%20Design.jpg\" \/>\n<meta name=\"author\" content=\"Prepbytes\" \/>\n<meta name=\"twitter:card\" content=\"summary_large_image\" \/>\n<meta name=\"twitter:label1\" content=\"Written by\" \/>\n\t<meta name=\"twitter:data1\" content=\"Prepbytes\" \/>\n<script type=\"application\/ld+json\" class=\"yoast-schema-graph\">{\"@context\":\"https:\/\/schema.org\",\"@graph\":[{\"@type\":\"Article\",\"@id\":\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#article\",\"isPartOf\":{\"@id\":\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/\"},\"author\":{\"name\":\"Prepbytes\",\"@id\":\"http:\/\/43.205.93.38\/#\/schema\/person\/3f7dc4ae851791d5947a7f99df363d5e\"},\"headline\":\"Basic Block In Compiler Design\",\"datePublished\":\"2023-06-27T06:54:05+00:00\",\"mainEntityOfPage\":{\"@id\":\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/\"},\"wordCount\":857,\"commentCount\":0,\"publisher\":{\"@id\":\"http:\/\/43.205.93.38\/#organization\"},\"image\":{\"@id\":\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/prepbytes-misc-images.s3.ap-south-1.amazonaws.com\/assets\/1687848482540-Basic%20Block%20In%20Compiler%20Design.jpg\",\"articleSection\":[\"CS Subjects\"],\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"CommentAction\",\"name\":\"Comment\",\"target\":[\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#respond\"]}]},{\"@type\":\"WebPage\",\"@id\":\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/\",\"url\":\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/\",\"name\":\"Basic Block In Compiler Design\",\"isPartOf\":{\"@id\":\"http:\/\/43.205.93.38\/#website\"},\"primaryImageOfPage\":{\"@id\":\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#primaryimage\"},\"image\":{\"@id\":\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#primaryimage\"},\"thumbnailUrl\":\"https:\/\/prepbytes-misc-images.s3.ap-south-1.amazonaws.com\/assets\/1687848482540-Basic%20Block%20In%20Compiler%20Design.jpg\",\"datePublished\":\"2023-06-27T06:54:05+00:00\",\"description\":\"A Basic Block refers to a linear sequence of code statements that lacks any internal branching, except at its start and end.\",\"breadcrumb\":{\"@id\":\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#breadcrumb\"},\"inLanguage\":\"en-US\",\"potentialAction\":[{\"@type\":\"ReadAction\",\"target\":[\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/\"]}]},{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#primaryimage\",\"url\":\"https:\/\/prepbytes-misc-images.s3.ap-south-1.amazonaws.com\/assets\/1687848482540-Basic%20Block%20In%20Compiler%20Design.jpg\",\"contentUrl\":\"https:\/\/prepbytes-misc-images.s3.ap-south-1.amazonaws.com\/assets\/1687848482540-Basic%20Block%20In%20Compiler%20Design.jpg\"},{\"@type\":\"BreadcrumbList\",\"@id\":\"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#breadcrumb\",\"itemListElement\":[{\"@type\":\"ListItem\",\"position\":1,\"name\":\"Home\",\"item\":\"http:\/\/43.205.93.38\/\"},{\"@type\":\"ListItem\",\"position\":2,\"name\":\"CS Subjects\",\"item\":\"https:\/\/prepbytes.com\/blog\/category\/cs-subjects\/\"},{\"@type\":\"ListItem\",\"position\":3,\"name\":\"Basic Block In Compiler Design\"}]},{\"@type\":\"WebSite\",\"@id\":\"http:\/\/43.205.93.38\/#website\",\"url\":\"http:\/\/43.205.93.38\/\",\"name\":\"PrepBytes Blog\",\"description\":\"ONE-STOP RESOURCE FOR EVERYTHING RELATED TO CODING\",\"publisher\":{\"@id\":\"http:\/\/43.205.93.38\/#organization\"},\"potentialAction\":[{\"@type\":\"SearchAction\",\"target\":{\"@type\":\"EntryPoint\",\"urlTemplate\":\"http:\/\/43.205.93.38\/?s={search_term_string}\"},\"query-input\":{\"@type\":\"PropertyValueSpecification\",\"valueRequired\":true,\"valueName\":\"search_term_string\"}}],\"inLanguage\":\"en-US\"},{\"@type\":\"Organization\",\"@id\":\"http:\/\/43.205.93.38\/#organization\",\"name\":\"Prepbytes\",\"url\":\"http:\/\/43.205.93.38\/\",\"logo\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"http:\/\/43.205.93.38\/#\/schema\/logo\/image\/\",\"url\":\"https:\/\/blog.prepbytes.com\/wp-content\/uploads\/2025\/07\/uzxxllgloialmn9mhwfe.webp\",\"contentUrl\":\"https:\/\/blog.prepbytes.com\/wp-content\/uploads\/2025\/07\/uzxxllgloialmn9mhwfe.webp\",\"width\":160,\"height\":160,\"caption\":\"Prepbytes\"},\"image\":{\"@id\":\"http:\/\/43.205.93.38\/#\/schema\/logo\/image\/\"},\"sameAs\":[\"https:\/\/www.facebook.com\/prepbytes0211\/\",\"https:\/\/www.instagram.com\/prepbytes\/\",\"https:\/\/www.linkedin.com\/company\/prepbytes\/\",\"https:\/\/www.youtube.com\/channel\/UC0xGnHDrjUM1pDEK2Ka5imA\"]},{\"@type\":\"Person\",\"@id\":\"http:\/\/43.205.93.38\/#\/schema\/person\/3f7dc4ae851791d5947a7f99df363d5e\",\"name\":\"Prepbytes\",\"image\":{\"@type\":\"ImageObject\",\"inLanguage\":\"en-US\",\"@id\":\"http:\/\/43.205.93.38\/#\/schema\/person\/image\/\",\"url\":\"https:\/\/secure.gravatar.com\/avatar\/232042cd1a1ea0e982c96d2a2ec93fb70a8e864e00784491231e7bfe5a9e06b5?s=96&d=mm&r=g\",\"contentUrl\":\"https:\/\/secure.gravatar.com\/avatar\/232042cd1a1ea0e982c96d2a2ec93fb70a8e864e00784491231e7bfe5a9e06b5?s=96&d=mm&r=g\",\"caption\":\"Prepbytes\"},\"url\":\"https:\/\/prepbytes.com\/blog\/author\/gourav-jaincollegedekho-com\/\"}]}<\/script>\n<!-- \/ Yoast SEO plugin. -->","yoast_head_json":{"title":"Basic Block In Compiler Design","description":"A Basic Block refers to a linear sequence of code statements that lacks any internal branching, except at its start and end.","robots":{"index":"index","follow":"follow","max-snippet":"max-snippet:-1","max-image-preview":"max-image-preview:large","max-video-preview":"max-video-preview:-1"},"canonical":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/","og_locale":"en_US","og_type":"article","og_title":"Basic Block In Compiler Design","og_description":"A Basic Block refers to a linear sequence of code statements that lacks any internal branching, except at its start and end.","og_url":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/","og_site_name":"PrepBytes Blog","article_publisher":"https:\/\/www.facebook.com\/prepbytes0211\/","article_published_time":"2023-06-27T06:54:05+00:00","og_image":[{"url":"https:\/\/prepbytes-misc-images.s3.ap-south-1.amazonaws.com\/assets\/1687848482540-Basic%20Block%20In%20Compiler%20Design.jpg","type":"","width":"","height":""}],"author":"Prepbytes","twitter_card":"summary_large_image","twitter_misc":{"Written by":"Prepbytes"},"schema":{"@context":"https:\/\/schema.org","@graph":[{"@type":"Article","@id":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#article","isPartOf":{"@id":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/"},"author":{"name":"Prepbytes","@id":"http:\/\/43.205.93.38\/#\/schema\/person\/3f7dc4ae851791d5947a7f99df363d5e"},"headline":"Basic Block In Compiler Design","datePublished":"2023-06-27T06:54:05+00:00","mainEntityOfPage":{"@id":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/"},"wordCount":857,"commentCount":0,"publisher":{"@id":"http:\/\/43.205.93.38\/#organization"},"image":{"@id":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#primaryimage"},"thumbnailUrl":"https:\/\/prepbytes-misc-images.s3.ap-south-1.amazonaws.com\/assets\/1687848482540-Basic%20Block%20In%20Compiler%20Design.jpg","articleSection":["CS Subjects"],"inLanguage":"en-US","potentialAction":[{"@type":"CommentAction","name":"Comment","target":["https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#respond"]}]},{"@type":"WebPage","@id":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/","url":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/","name":"Basic Block In Compiler Design","isPartOf":{"@id":"http:\/\/43.205.93.38\/#website"},"primaryImageOfPage":{"@id":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#primaryimage"},"image":{"@id":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#primaryimage"},"thumbnailUrl":"https:\/\/prepbytes-misc-images.s3.ap-south-1.amazonaws.com\/assets\/1687848482540-Basic%20Block%20In%20Compiler%20Design.jpg","datePublished":"2023-06-27T06:54:05+00:00","description":"A Basic Block refers to a linear sequence of code statements that lacks any internal branching, except at its start and end.","breadcrumb":{"@id":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#breadcrumb"},"inLanguage":"en-US","potentialAction":[{"@type":"ReadAction","target":["https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/"]}]},{"@type":"ImageObject","inLanguage":"en-US","@id":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#primaryimage","url":"https:\/\/prepbytes-misc-images.s3.ap-south-1.amazonaws.com\/assets\/1687848482540-Basic%20Block%20In%20Compiler%20Design.jpg","contentUrl":"https:\/\/prepbytes-misc-images.s3.ap-south-1.amazonaws.com\/assets\/1687848482540-Basic%20Block%20In%20Compiler%20Design.jpg"},{"@type":"BreadcrumbList","@id":"https:\/\/prepbytes.com\/blog\/basic-block-in-compiler-design\/#breadcrumb","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"http:\/\/43.205.93.38\/"},{"@type":"ListItem","position":2,"name":"CS Subjects","item":"https:\/\/prepbytes.com\/blog\/category\/cs-subjects\/"},{"@type":"ListItem","position":3,"name":"Basic Block In Compiler Design"}]},{"@type":"WebSite","@id":"http:\/\/43.205.93.38\/#website","url":"http:\/\/43.205.93.38\/","name":"PrepBytes Blog","description":"ONE-STOP RESOURCE FOR EVERYTHING RELATED TO CODING","publisher":{"@id":"http:\/\/43.205.93.38\/#organization"},"potentialAction":[{"@type":"SearchAction","target":{"@type":"EntryPoint","urlTemplate":"http:\/\/43.205.93.38\/?s={search_term_string}"},"query-input":{"@type":"PropertyValueSpecification","valueRequired":true,"valueName":"search_term_string"}}],"inLanguage":"en-US"},{"@type":"Organization","@id":"http:\/\/43.205.93.38\/#organization","name":"Prepbytes","url":"http:\/\/43.205.93.38\/","logo":{"@type":"ImageObject","inLanguage":"en-US","@id":"http:\/\/43.205.93.38\/#\/schema\/logo\/image\/","url":"https:\/\/blog.prepbytes.com\/wp-content\/uploads\/2025\/07\/uzxxllgloialmn9mhwfe.webp","contentUrl":"https:\/\/blog.prepbytes.com\/wp-content\/uploads\/2025\/07\/uzxxllgloialmn9mhwfe.webp","width":160,"height":160,"caption":"Prepbytes"},"image":{"@id":"http:\/\/43.205.93.38\/#\/schema\/logo\/image\/"},"sameAs":["https:\/\/www.facebook.com\/prepbytes0211\/","https:\/\/www.instagram.com\/prepbytes\/","https:\/\/www.linkedin.com\/company\/prepbytes\/","https:\/\/www.youtube.com\/channel\/UC0xGnHDrjUM1pDEK2Ka5imA"]},{"@type":"Person","@id":"http:\/\/43.205.93.38\/#\/schema\/person\/3f7dc4ae851791d5947a7f99df363d5e","name":"Prepbytes","image":{"@type":"ImageObject","inLanguage":"en-US","@id":"http:\/\/43.205.93.38\/#\/schema\/person\/image\/","url":"https:\/\/secure.gravatar.com\/avatar\/232042cd1a1ea0e982c96d2a2ec93fb70a8e864e00784491231e7bfe5a9e06b5?s=96&d=mm&r=g","contentUrl":"https:\/\/secure.gravatar.com\/avatar\/232042cd1a1ea0e982c96d2a2ec93fb70a8e864e00784491231e7bfe5a9e06b5?s=96&d=mm&r=g","caption":"Prepbytes"},"url":"https:\/\/prepbytes.com\/blog\/author\/gourav-jaincollegedekho-com\/"}]}},"_links":{"self":[{"href":"https:\/\/prepbytes.com\/blog\/wp-json\/wp\/v2\/posts\/16897","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/prepbytes.com\/blog\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/prepbytes.com\/blog\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/prepbytes.com\/blog\/wp-json\/wp\/v2\/users\/52"}],"replies":[{"embeddable":true,"href":"https:\/\/prepbytes.com\/blog\/wp-json\/wp\/v2\/comments?post=16897"}],"version-history":[{"count":1,"href":"https:\/\/prepbytes.com\/blog\/wp-json\/wp\/v2\/posts\/16897\/revisions"}],"predecessor-version":[{"id":16898,"href":"https:\/\/prepbytes.com\/blog\/wp-json\/wp\/v2\/posts\/16897\/revisions\/16898"}],"wp:attachment":[{"href":"https:\/\/prepbytes.com\/blog\/wp-json\/wp\/v2\/media?parent=16897"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/prepbytes.com\/blog\/wp-json\/wp\/v2\/categories?post=16897"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/prepbytes.com\/blog\/wp-json\/wp\/v2\/tags?post=16897"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}