Section: 
Section: .interp
Section: .note.gnu.property
Section: .note.gnu.build-id
Section: .note.ABI-tag
Section: .gnu.hash
Section: .dynsym
Section: .dynstr
Section: .gnu.version
Section: .gnu.version_r
Section: .rela.dyn
Section: .rela.plt
Section: .init
Section: .plt
Section: .plt.got
Section: .plt.sec
Section: .text
Section: .fini
Section: .rodata
Section: .eh_frame_hdr
Section: .eh_frame
Section: .gcc_except_table
Section: .init_array
Section: .fini_array
Section: .dynamic
Section: .got
Section: .data
Section: .bss
Section: .comment
Section: .debug_aranges
Section: .debug_info
Section: .debug_abbrev
Section: .debug_line
Section: .debug_str
Section: .debug_line_str
Section: .debug_rnglists
Section: .symtab
Section: .strtab
Section: .shstrtab
Debugging sections not found
Creating initial loop nests...
Injecting realization of { next }
for (.__root, 0, 1) {
 produce next {
  let next.s0.si.loop_max = next.s0.si.max
  let next.s0.si.loop_min = next.s0.si.min
  let next.s0.si.loop_extent = (next.s0.si.max + 1) - next.s0.si.min
  let next.s0.__outermost.loop_extent = 1
  let next.s0.__outermost.loop_max = 0
  let next.s0.__outermost.loop_min = 0
  for (next.s0.__outermost, next.s0.__outermost.loop_min, next.s0.__outermost.loop_extent) {
   for (next.s0.si, next.s0.si.loop_min, next.s0.si.loop_extent) {
    next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
   }
  }
 }
}

Injecting realization of { denominator, numerator }
for (.__root, 0, 1) {
 realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
  realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
   produce numerator {
    produce denominator {
     let denominator.s0.si.loop_max = denominator.s0.si.max
     let denominator.s0.si.loop_min = denominator.s0.si.min
     let denominator.s0.si.loop_extent = (denominator.s0.si.max + 1) - denominator.s0.si.min
     let denominator.s0.i.loop_max = denominator.s0.i.max
     let denominator.s0.i.loop_min = denominator.s0.i.min
     let denominator.s0.i.loop_extent = (denominator.s0.i.max + 1) - denominator.s0.i.min
     let denominator.s0.__outermost.loop_extent = 1
     let denominator.s0.__outermost.loop_max = 0
     let denominator.s0.__outermost.loop_min = 0
     let numerator.s0.si.loop_max = numerator.s0.si.max
     let numerator.s0.si.loop_min = numerator.s0.si.min
     let numerator.s0.si.loop_extent = (numerator.s0.si.max + 1) - numerator.s0.si.min
     let numerator.s0.__outermost.loop_extent = 1
     let numerator.s0.__outermost.loop_max = 0
     let numerator.s0.__outermost.loop_min = 0
     let numerator.s1.rv$x.loop_extent = (numerator.s1.rv$x.max - numerator.s1.rv$x.min) + 1
     let numerator.s1.rv$x.loop_max = numerator.s1.rv$x.max
     let numerator.s1.rv$x.loop_min = numerator.s1.rv$x.min
     let numerator.s1.si.loop_max = numerator.s1.si.max
     let numerator.s1.si.loop_min = numerator.s1.si.min
     let numerator.s1.si.loop_extent = (numerator.s1.si.max + 1) - numerator.s1.si.min
     let numerator.s1.__outermost.loop_extent = 1
     let numerator.s1.__outermost.loop_max = 0
     let numerator.s1.__outermost.loop_min = 0
     let denominator.s1.rv$x.loop_extent = (denominator.s1.rv$x.max - denominator.s1.rv$x.min) + 1
     let denominator.s1.rv$x.loop_max = denominator.s1.rv$x.max
     let denominator.s1.rv$x.loop_min = denominator.s1.rv$x.min
     let denominator.s1.si.loop_max = denominator.s1.si.max
     let denominator.s1.si.loop_min = denominator.s1.si.min
     let denominator.s1.si.loop_extent = (denominator.s1.si.max + 1) - denominator.s1.si.min
     let denominator.s1.i.loop_max = denominator.s1.i.max
     let denominator.s1.i.loop_min = denominator.s1.i.min
     let denominator.s1.i.loop_extent = (denominator.s1.i.max + 1) - denominator.s1.i.min
     let denominator.s1.__outermost.loop_extent = 1
     let denominator.s1.__outermost.loop_max = 0
     let denominator.s1.__outermost.loop_min = 0
     for (denominator.s0.__outermost, denominator.s0.__outermost.loop_min, denominator.s0.__outermost.loop_extent) {
      for (denominator.s0.si, denominator.s0.si.loop_min, denominator.s0.si.loop_extent) {
       for (denominator.s0.i, denominator.s0.i.loop_min, denominator.s0.i.loop_extent) {
        denominator(denominator.s0.i, denominator.s0.si) = 0
       }
      }
     }
     for (numerator.s0.__outermost, numerator.s0.__outermost.loop_min, numerator.s0.__outermost.loop_extent) {
      for (numerator.s0.si, numerator.s0.si.loop_min, numerator.s0.si.loop_extent) {
       numerator(numerator.s0.si) = 0
      }
     }
     for (numerator.s1.__outermost, numerator.s1.__outermost.loop_min, numerator.s1.__outermost.loop_extent) {
      for (numerator.s1.rv$x, numerator.s1.rv$x.loop_min, numerator.s1.rv$x.loop_extent) {
       if ((uint1)likely(numerator.s1.rv$x >= numerator.s1.rv$x.loop_min)) {
        if ((uint1)likely(numerator.s1.rv$x <= numerator.s1.rv$x.loop_max)) {
         numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
        }
       }
       for (denominator.s1.__outermost, denominator.s1.__outermost.loop_min, denominator.s1.__outermost.loop_extent) {
        let denominator.s1.fused.rv$x.loop_extent = 1
        let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
        let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
        for (denominator.s1.fused.rv$x, denominator.s1.fused.rv$x.loop_min, denominator.s1.fused.rv$x.loop_extent) {
         for (denominator.s1.i, denominator.s1.i.loop_min, denominator.s1.i.loop_extent) {
          if ((uint1)likely(denominator.s1.fused.rv$x >= denominator.s1.rv$x.loop_min)) {
           if ((uint1)likely(denominator.s1.fused.rv$x <= denominator.s1.rv$x.loop_max)) {
            denominator(denominator.s1.i, denominator.s1.fused.rv$x) = denominator(denominator.s1.i, denominator.s1.fused.rv$x) + denominator_inter(denominator.s1.i, denominator.s1.fused.rv$x)
           }
          }
         }
        }
       }
      }
     }
    }
   }
   consume numerator {
    consume denominator {
     produce next {
      let next.s0.si.loop_max = next.s0.si.max
      let next.s0.si.loop_min = next.s0.si.min
      let next.s0.si.loop_extent = (next.s0.si.max + 1) - next.s0.si.min
      let next.s0.__outermost.loop_extent = 1
      let next.s0.__outermost.loop_max = 0
      let next.s0.__outermost.loop_min = 0
      for (next.s0.__outermost, next.s0.__outermost.loop_min, next.s0.__outermost.loop_extent) {
       for (next.s0.si, next.s0.si.loop_min, next.s0.si.loop_extent) {
        next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
       }
      }
     }
    }
   }
  }
 }
}

Injecting realization of { denominator_inter }
for (.__root, 0, 1) {
 realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
  realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
   produce numerator {
    produce denominator {
     let denominator.s0.si.loop_max = denominator.s0.si.max
     let denominator.s0.si.loop_min = denominator.s0.si.min
     let denominator.s0.si.loop_extent = (denominator.s0.si.max + 1) - denominator.s0.si.min
     let denominator.s0.i.loop_max = denominator.s0.i.max
     let denominator.s0.i.loop_min = denominator.s0.i.min
     let denominator.s0.i.loop_extent = (denominator.s0.i.max + 1) - denominator.s0.i.min
     let denominator.s0.__outermost.loop_extent = 1
     let denominator.s0.__outermost.loop_max = 0
     let denominator.s0.__outermost.loop_min = 0
     let numerator.s0.si.loop_max = numerator.s0.si.max
     let numerator.s0.si.loop_min = numerator.s0.si.min
     let numerator.s0.si.loop_extent = (numerator.s0.si.max + 1) - numerator.s0.si.min
     let numerator.s0.__outermost.loop_extent = 1
     let numerator.s0.__outermost.loop_max = 0
     let numerator.s0.__outermost.loop_min = 0
     let numerator.s1.rv$x.loop_extent = (numerator.s1.rv$x.max - numerator.s1.rv$x.min) + 1
     let numerator.s1.rv$x.loop_max = numerator.s1.rv$x.max
     let numerator.s1.rv$x.loop_min = numerator.s1.rv$x.min
     let numerator.s1.si.loop_max = numerator.s1.si.max
     let numerator.s1.si.loop_min = numerator.s1.si.min
     let numerator.s1.si.loop_extent = (numerator.s1.si.max + 1) - numerator.s1.si.min
     let numerator.s1.__outermost.loop_extent = 1
     let numerator.s1.__outermost.loop_max = 0
     let numerator.s1.__outermost.loop_min = 0
     let denominator.s1.rv$x.loop_extent = (denominator.s1.rv$x.max - denominator.s1.rv$x.min) + 1
     let denominator.s1.rv$x.loop_max = denominator.s1.rv$x.max
     let denominator.s1.rv$x.loop_min = denominator.s1.rv$x.min
     let denominator.s1.si.loop_max = denominator.s1.si.max
     let denominator.s1.si.loop_min = denominator.s1.si.min
     let denominator.s1.si.loop_extent = (denominator.s1.si.max + 1) - denominator.s1.si.min
     let denominator.s1.i.loop_max = denominator.s1.i.max
     let denominator.s1.i.loop_min = denominator.s1.i.min
     let denominator.s1.i.loop_extent = (denominator.s1.i.max + 1) - denominator.s1.i.min
     let denominator.s1.__outermost.loop_extent = 1
     let denominator.s1.__outermost.loop_max = 0
     let denominator.s1.__outermost.loop_min = 0
     for (denominator.s0.__outermost, denominator.s0.__outermost.loop_min, denominator.s0.__outermost.loop_extent) {
      for (denominator.s0.si, denominator.s0.si.loop_min, denominator.s0.si.loop_extent) {
       for (denominator.s0.i, denominator.s0.i.loop_min, denominator.s0.i.loop_extent) {
        denominator(denominator.s0.i, denominator.s0.si) = 0
       }
      }
     }
     for (numerator.s0.__outermost, numerator.s0.__outermost.loop_min, numerator.s0.__outermost.loop_extent) {
      for (numerator.s0.si, numerator.s0.si.loop_min, numerator.s0.si.loop_extent) {
       numerator(numerator.s0.si) = 0
      }
     }
     for (numerator.s1.__outermost, numerator.s1.__outermost.loop_min, numerator.s1.__outermost.loop_extent) {
      for (numerator.s1.rv$x, numerator.s1.rv$x.loop_min, numerator.s1.rv$x.loop_extent) {
       if ((uint1)likely(numerator.s1.rv$x >= numerator.s1.rv$x.loop_min)) {
        if ((uint1)likely(numerator.s1.rv$x <= numerator.s1.rv$x.loop_max)) {
         numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
        }
       }
       for (denominator.s1.__outermost, denominator.s1.__outermost.loop_min, denominator.s1.__outermost.loop_extent) {
        let denominator.s1.fused.rv$x.loop_extent = 1
        let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
        let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
        for (denominator.s1.fused.rv$x, denominator.s1.fused.rv$x.loop_min, denominator.s1.fused.rv$x.loop_extent) {
         for (denominator.s1.i, denominator.s1.i.loop_min, denominator.s1.i.loop_extent) {
          if ((uint1)likely(denominator.s1.fused.rv$x >= denominator.s1.rv$x.loop_min)) {
           if ((uint1)likely(denominator.s1.fused.rv$x <= denominator.s1.rv$x.loop_max)) {
            realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
             produce denominator_inter {
              let denominator_inter.s0.vis.loop_max = denominator_inter.s0.vis.max
              let denominator_inter.s0.vis.loop_min = denominator_inter.s0.vis.min
              let denominator_inter.s0.vis.loop_extent = (denominator_inter.s0.vis.max + 1) - denominator_inter.s0.vis.min
              let denominator_inter.s0.i.loop_max = denominator_inter.s0.i.max
              let denominator_inter.s0.i.loop_min = denominator_inter.s0.i.min
              let denominator_inter.s0.i.loop_extent = (denominator_inter.s0.i.max + 1) - denominator_inter.s0.i.min
              let denominator_inter.s0.__outermost.loop_extent = 1
              let denominator_inter.s0.__outermost.loop_max = 0
              let denominator_inter.s0.__outermost.loop_min = 0
              let denominator_inter.s1.vis.loop_max = denominator_inter.s1.vis.max
              let denominator_inter.s1.vis.loop_min = denominator_inter.s1.vis.min
              let denominator_inter.s1.vis.loop_extent = (denominator_inter.s1.vis.max + 1) - denominator_inter.s1.vis.min
              let denominator_inter.s1.i.loop_max = denominator_inter.s1.i.max
              let denominator_inter.s1.i.loop_min = denominator_inter.s1.i.min
              let denominator_inter.s1.i.loop_extent = (denominator_inter.s1.i.max + 1) - denominator_inter.s1.i.min
              let denominator_inter.s1.__outermost.loop_extent = 1
              let denominator_inter.s1.__outermost.loop_max = 0
              let denominator_inter.s1.__outermost.loop_min = 0
              for (denominator_inter.s0.__outermost, denominator_inter.s0.__outermost.loop_min, denominator_inter.s0.__outermost.loop_extent) {
               for (denominator_inter.s0.vis, denominator_inter.s0.vis.loop_min, denominator_inter.s0.vis.loop_extent) {
                for (denominator_inter.s0.i, denominator_inter.s0.i.loop_min, denominator_inter.s0.i.loop_extent) {
                 denominator_inter(denominator_inter.s0.i, denominator_inter.s0.vis) = 0
                }
               }
              }
              for (denominator_inter.s1.__outermost, denominator_inter.s1.__outermost.loop_min, denominator_inter.s1.__outermost.loop_extent) {
               for (denominator_inter.s1.vis, denominator_inter.s1.vis.loop_min, denominator_inter.s1.vis.loop_extent) {
                denominator_inter(0, denominator_inter.s1.vis) = 0 + denominator_inter.s1.vis
               }
              }
             }
             consume denominator_inter {
              denominator(denominator.s1.i, denominator.s1.fused.rv$x) = denominator(denominator.s1.i, denominator.s1.fused.rv$x) + denominator_inter(denominator.s1.i, denominator.s1.fused.rv$x)
             }
            }
           }
          }
         }
        }
       }
      }
     }
    }
   }
   consume numerator {
    consume denominator {
     produce next {
      let next.s0.si.loop_max = next.s0.si.max
      let next.s0.si.loop_min = next.s0.si.min
      let next.s0.si.loop_extent = (next.s0.si.max + 1) - next.s0.si.min
      let next.s0.__outermost.loop_extent = 1
      let next.s0.__outermost.loop_max = 0
      let next.s0.__outermost.loop_min = 0
      for (next.s0.__outermost, next.s0.__outermost.loop_min, next.s0.__outermost.loop_extent) {
       for (next.s0.si, next.s0.si.loop_min, next.s0.si.loop_extent) {
        next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
       }
      }
     }
    }
   }
  }
 }
}

Lowering after creating initial loop nests:
realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
 realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
  produce numerator {
   produce denominator {
    let denominator.s0.si.loop_max = denominator.s0.si.max
    let denominator.s0.si.loop_min = denominator.s0.si.min
    let denominator.s0.si.loop_extent = (denominator.s0.si.max + 1) - denominator.s0.si.min
    let denominator.s0.i.loop_max = denominator.s0.i.max
    let denominator.s0.i.loop_min = denominator.s0.i.min
    let denominator.s0.i.loop_extent = (denominator.s0.i.max + 1) - denominator.s0.i.min
    let numerator.s0.si.loop_max = numerator.s0.si.max
    let numerator.s0.si.loop_min = numerator.s0.si.min
    let numerator.s0.si.loop_extent = (numerator.s0.si.max + 1) - numerator.s0.si.min
    let numerator.s1.rv$x.loop_extent = (numerator.s1.rv$x.max - numerator.s1.rv$x.min) + 1
    let numerator.s1.rv$x.loop_max = numerator.s1.rv$x.max
    let numerator.s1.rv$x.loop_min = numerator.s1.rv$x.min
    let numerator.s1.si.loop_max = numerator.s1.si.max
    let numerator.s1.si.loop_min = numerator.s1.si.min
    let numerator.s1.si.loop_extent = (numerator.s1.si.max + 1) - numerator.s1.si.min
    let denominator.s1.rv$x.loop_extent = (denominator.s1.rv$x.max - denominator.s1.rv$x.min) + 1
    let denominator.s1.rv$x.loop_max = denominator.s1.rv$x.max
    let denominator.s1.rv$x.loop_min = denominator.s1.rv$x.min
    let denominator.s1.si.loop_max = denominator.s1.si.max
    let denominator.s1.si.loop_min = denominator.s1.si.min
    let denominator.s1.si.loop_extent = (denominator.s1.si.max + 1) - denominator.s1.si.min
    let denominator.s1.i.loop_max = denominator.s1.i.max
    let denominator.s1.i.loop_min = denominator.s1.i.min
    let denominator.s1.i.loop_extent = (denominator.s1.i.max + 1) - denominator.s1.i.min
    for (denominator.s0.si, denominator.s0.si.loop_min, denominator.s0.si.loop_extent) {
     for (denominator.s0.i, denominator.s0.i.loop_min, denominator.s0.i.loop_extent) {
      denominator(denominator.s0.i, denominator.s0.si) = 0
     }
    }
    for (numerator.s0.si, numerator.s0.si.loop_min, numerator.s0.si.loop_extent) {
     numerator(numerator.s0.si) = 0
    }
    for (numerator.s1.rv$x, numerator.s1.rv$x.loop_min, numerator.s1.rv$x.loop_extent) {
     if ((uint1)likely(numerator.s1.rv$x >= numerator.s1.rv$x.loop_min)) {
      if ((uint1)likely(numerator.s1.rv$x <= numerator.s1.rv$x.loop_max)) {
       numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
      }
     }
     let denominator.s1.fused.rv$x.loop_extent = 1
     let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
     for (denominator.s1.fused.rv$x, denominator.s1.fused.rv$x.loop_min, denominator.s1.fused.rv$x.loop_extent) {
      for (denominator.s1.i, denominator.s1.i.loop_min, denominator.s1.i.loop_extent) {
       if ((uint1)likely(denominator.s1.fused.rv$x >= denominator.s1.rv$x.loop_min)) {
        if ((uint1)likely(denominator.s1.fused.rv$x <= denominator.s1.rv$x.loop_max)) {
         realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
          produce denominator_inter {
           let denominator_inter.s0.vis.loop_max = denominator_inter.s0.vis.max
           let denominator_inter.s0.vis.loop_min = denominator_inter.s0.vis.min
           let denominator_inter.s0.vis.loop_extent = (denominator_inter.s0.vis.max + 1) - denominator_inter.s0.vis.min
           let denominator_inter.s0.i.loop_max = denominator_inter.s0.i.max
           let denominator_inter.s0.i.loop_min = denominator_inter.s0.i.min
           let denominator_inter.s0.i.loop_extent = (denominator_inter.s0.i.max + 1) - denominator_inter.s0.i.min
           let denominator_inter.s1.vis.loop_max = denominator_inter.s1.vis.max
           let denominator_inter.s1.vis.loop_min = denominator_inter.s1.vis.min
           let denominator_inter.s1.vis.loop_extent = (denominator_inter.s1.vis.max + 1) - denominator_inter.s1.vis.min
           let denominator_inter.s1.i.loop_max = denominator_inter.s1.i.max
           let denominator_inter.s1.i.loop_min = denominator_inter.s1.i.min
           let denominator_inter.s1.i.loop_extent = (denominator_inter.s1.i.max + 1) - denominator_inter.s1.i.min
           for (denominator_inter.s0.vis, denominator_inter.s0.vis.loop_min, denominator_inter.s0.vis.loop_extent) {
            for (denominator_inter.s0.i, denominator_inter.s0.i.loop_min, denominator_inter.s0.i.loop_extent) {
             denominator_inter(denominator_inter.s0.i, denominator_inter.s0.vis) = 0
            }
           }
           for (denominator_inter.s1.vis, denominator_inter.s1.vis.loop_min, denominator_inter.s1.vis.loop_extent) {
            denominator_inter(0, denominator_inter.s1.vis) = 0 + denominator_inter.s1.vis
           }
          }
          consume denominator_inter {
           denominator(denominator.s1.i, denominator.s1.fused.rv$x) = denominator(denominator.s1.i, denominator.s1.fused.rv$x) + denominator_inter(denominator.s1.i, denominator.s1.fused.rv$x)
          }
         }
        }
       }
      }
     }
    }
   }
  }
  consume numerator {
   consume denominator {
    produce next {
     let next.s0.si.loop_max = next.s0.si.max
     let next.s0.si.loop_min = next.s0.si.min
     let next.s0.si.loop_extent = (next.s0.si.max + 1) - next.s0.si.min
     for (next.s0.si, next.s0.si.loop_min, next.s0.si.loop_extent) {
      next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
     }
    }
   }
  }
 }
}

Skipping injecting memoization...
Injecting tracing...
Lowering after injecting tracing: (unchanged)

Adding checks for parameters
Lowering after injecting parameter checks: (unchanged)

Computing bounds of each function's value
Bounds on value 0 for func denominator_inter are: (void *)neg_inf, (void *)pos_inf
Bounds on value 0 for func denominator are: (void *)neg_inf, (void *)pos_inf
Bounds on value 0 for func numerator are: (void *)neg_inf, (void *)pos_inf
Bounds on value 0 for func next are: (void *)neg_inf, (void *)pos_inf
Clamping unsafe data-dependent accesses
Lowering after clamping unsafe data-dependent accesses
realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
 realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
  produce numerator {
   produce denominator {
    let denominator.s0.si.loop_max = denominator.s0.si.max
    let denominator.s0.si.loop_min = denominator.s0.si.min
    let denominator.s0.si.loop_extent = (denominator.s0.si.max + 1) - denominator.s0.si.min
    let denominator.s0.i.loop_max = denominator.s0.i.max
    let denominator.s0.i.loop_min = denominator.s0.i.min
    let denominator.s0.i.loop_extent = (denominator.s0.i.max + 1) - denominator.s0.i.min
    let numerator.s0.si.loop_max = numerator.s0.si.max
    let numerator.s0.si.loop_min = numerator.s0.si.min
    let numerator.s0.si.loop_extent = (numerator.s0.si.max + 1) - numerator.s0.si.min
    let numerator.s1.rv$x.loop_extent = (numerator.s1.rv$x.max - numerator.s1.rv$x.min) + 1
    let numerator.s1.rv$x.loop_max = numerator.s1.rv$x.max
    let numerator.s1.rv$x.loop_min = numerator.s1.rv$x.min
    let numerator.s1.si.loop_max = numerator.s1.si.max
    let numerator.s1.si.loop_min = numerator.s1.si.min
    let numerator.s1.si.loop_extent = (numerator.s1.si.max + 1) - numerator.s1.si.min
    let denominator.s1.rv$x.loop_extent = (denominator.s1.rv$x.max - denominator.s1.rv$x.min) + 1
    let denominator.s1.rv$x.loop_max = denominator.s1.rv$x.max
    let denominator.s1.rv$x.loop_min = denominator.s1.rv$x.min
    let denominator.s1.si.loop_max = denominator.s1.si.max
    let denominator.s1.si.loop_min = denominator.s1.si.min
    let denominator.s1.si.loop_extent = (denominator.s1.si.max + 1) - denominator.s1.si.min
    let denominator.s1.i.loop_max = denominator.s1.i.max
    let denominator.s1.i.loop_min = denominator.s1.i.min
    let denominator.s1.i.loop_extent = (denominator.s1.i.max + 1) - denominator.s1.i.min
    for (denominator.s0.si, denominator.s0.si.loop_min, denominator.s0.si.loop_extent) {
     for (denominator.s0.i, denominator.s0.i.loop_min, denominator.s0.i.loop_extent) {
      denominator(denominator.s0.i, denominator.s0.si) = 0
     }
    }
    for (numerator.s0.si, numerator.s0.si.loop_min, numerator.s0.si.loop_extent) {
     numerator(numerator.s0.si) = 0
    }
    for (numerator.s1.rv$x, numerator.s1.rv$x.loop_min, numerator.s1.rv$x.loop_extent) {
     if ((uint1)likely(numerator.s1.rv$x >= numerator.s1.rv$x.loop_min)) {
      if ((uint1)likely(numerator.s1.rv$x <= numerator.s1.rv$x.loop_max)) {
       numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
      }
     }
     let denominator.s1.fused.rv$x.loop_extent = 1
     let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
     for (denominator.s1.fused.rv$x, denominator.s1.fused.rv$x.loop_min, denominator.s1.fused.rv$x.loop_extent) {
      for (denominator.s1.i, denominator.s1.i.loop_min, denominator.s1.i.loop_extent) {
       if ((uint1)likely(denominator.s1.fused.rv$x >= denominator.s1.rv$x.loop_min)) {
        if ((uint1)likely(denominator.s1.fused.rv$x <= denominator.s1.rv$x.loop_max)) {
         realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
          produce denominator_inter {
           let denominator_inter.s0.vis.loop_max = denominator_inter.s0.vis.max
           let denominator_inter.s0.vis.loop_min = denominator_inter.s0.vis.min
           let denominator_inter.s0.vis.loop_extent = (denominator_inter.s0.vis.max + 1) - denominator_inter.s0.vis.min
           let denominator_inter.s0.i.loop_max = denominator_inter.s0.i.max
           let denominator_inter.s0.i.loop_min = denominator_inter.s0.i.min
           let denominator_inter.s0.i.loop_extent = (denominator_inter.s0.i.max + 1) - denominator_inter.s0.i.min
           let denominator_inter.s1.vis.loop_max = denominator_inter.s1.vis.max
           let denominator_inter.s1.vis.loop_min = denominator_inter.s1.vis.min
           let denominator_inter.s1.vis.loop_extent = (denominator_inter.s1.vis.max + 1) - denominator_inter.s1.vis.min
           let denominator_inter.s1.i.loop_max = denominator_inter.s1.i.max
           let denominator_inter.s1.i.loop_min = denominator_inter.s1.i.min
           let denominator_inter.s1.i.loop_extent = (denominator_inter.s1.i.max + 1) - denominator_inter.s1.i.min
           for (denominator_inter.s0.vis, denominator_inter.s0.vis.loop_min, denominator_inter.s0.vis.loop_extent) {
            for (denominator_inter.s0.i, denominator_inter.s0.i.loop_min, denominator_inter.s0.i.loop_extent) {
             denominator_inter(denominator_inter.s0.i, denominator_inter.s0.vis) = 0
            }
           }
           for (denominator_inter.s1.vis, denominator_inter.s1.vis.loop_min, denominator_inter.s1.vis.loop_extent) {
            denominator_inter(0, denominator_inter.s1.vis) = 0 + denominator_inter.s1.vis
           }
          }
          consume denominator_inter {
           denominator(denominator.s1.i, denominator.s1.fused.rv$x) = denominator(denominator.s1.i, denominator.s1.fused.rv$x) + denominator_inter(denominator.s1.i, denominator.s1.fused.rv$x)
          }
         }
        }
       }
      }
     }
    }
   }
  }
  consume numerator {
   consume denominator {
    produce next {
     let next.s0.si.loop_max = next.s0.si.max
     let next.s0.si.loop_min = next.s0.si.min
     let next.s0.si.loop_extent = (next.s0.si.max + 1) - next.s0.si.min
     for (next.s0.si, next.s0.si.loop_min, next.s0.si.loop_extent) {
      next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
     }
    }
   }
  }
 }
}

Performing computation bounds inference...
Lowering after computation bounds inference:
let next.s0.si.max = (next.min.0 + next.extent.0) - 1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = (10 + 0) - 1
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = next.s0.si.max
let numerator.s1.si.min = next.s0.si.min
let numerator.s0.si.max = max(next.s0.si.max, numerator.s1.rv$x.max)
let numerator.s0.si.min = min(next.s0.si.min, numerator.s1.rv$x.min)
let denominator.s1.rv$x.max = (10 + 0) - 1
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = next.s0.si.max
let denominator.s1.si.min = next.s0.si.min
let denominator.s1.i.max = 0
let denominator.s1.i.min = denominator.s1.i.max
let denominator.s0.si.max = max(denominator.s1.rv$x.max, next.s0.si.max)
let denominator.s0.si.min = min(denominator.s1.rv$x.min, next.s0.si.min)
let denominator.s0.i.max = denominator.s1.i.max
let denominator.s0.i.min = denominator.s1.i.min
let denominator_inter.s1.vis.max = denominator.s1.rv$x.max
let denominator_inter.s1.vis.min = denominator.s1.rv$x.min
let denominator_inter.s1.i.max = denominator.s1.i.max
let denominator_inter.s1.i.min = denominator.s1.i.min
let denominator_inter.s0.vis.max = denominator_inter.s1.vis.max
let denominator_inter.s0.vis.min = denominator_inter.s1.vis.min
let denominator_inter.s0.i.max = denominator.s1.i.max
let denominator_inter.s0.i.min = denominator.s1.i.min
add_image_checks_marker()
realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
 realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
  produce numerator {
   produce denominator {
    let denominator.s0.si.loop_max = denominator.s0.si.max
    let denominator.s0.si.loop_min = denominator.s0.si.min
    let denominator.s0.si.loop_extent = (denominator.s0.si.max + 1) - denominator.s0.si.min
    let denominator.s0.i.loop_max = denominator.s0.i.max
    let denominator.s0.i.loop_min = denominator.s0.i.min
    let denominator.s0.i.loop_extent = (denominator.s0.i.max + 1) - denominator.s0.i.min
    let numerator.s0.si.loop_max = numerator.s0.si.max
    let numerator.s0.si.loop_min = numerator.s0.si.min
    let numerator.s0.si.loop_extent = (numerator.s0.si.max + 1) - numerator.s0.si.min
    let numerator.s1.rv$x.loop_extent = (numerator.s1.rv$x.max - numerator.s1.rv$x.min) + 1
    let numerator.s1.rv$x.loop_max = numerator.s1.rv$x.max
    let numerator.s1.rv$x.loop_min = numerator.s1.rv$x.min
    let numerator.s1.si.loop_max = numerator.s1.si.max
    let numerator.s1.si.loop_min = numerator.s1.si.min
    let numerator.s1.si.loop_extent = (numerator.s1.si.max + 1) - numerator.s1.si.min
    let denominator.s1.rv$x.loop_extent = (denominator.s1.rv$x.max - denominator.s1.rv$x.min) + 1
    let denominator.s1.rv$x.loop_max = denominator.s1.rv$x.max
    let denominator.s1.rv$x.loop_min = denominator.s1.rv$x.min
    let denominator.s1.si.loop_max = denominator.s1.si.max
    let denominator.s1.si.loop_min = denominator.s1.si.min
    let denominator.s1.si.loop_extent = (denominator.s1.si.max + 1) - denominator.s1.si.min
    let denominator.s1.i.loop_max = denominator.s1.i.max
    let denominator.s1.i.loop_min = denominator.s1.i.min
    let denominator.s1.i.loop_extent = (denominator.s1.i.max + 1) - denominator.s1.i.min
    for (denominator.s0.si, denominator.s0.si.loop_min, denominator.s0.si.loop_extent) {
     for (denominator.s0.i, denominator.s0.i.loop_min, denominator.s0.i.loop_extent) {
      denominator(denominator.s0.i, denominator.s0.si) = 0
     }
    }
    for (numerator.s0.si, numerator.s0.si.loop_min, numerator.s0.si.loop_extent) {
     numerator(numerator.s0.si) = 0
    }
    for (numerator.s1.rv$x, numerator.s1.rv$x.loop_min, numerator.s1.rv$x.loop_extent) {
     let numerator.s1.rv$x.max = numerator.s1.rv$x
     let numerator.s1.rv$x.min = numerator.s1.rv$x
     let denominator.s1.rv$x.max = denominator.s1.rv$x
     let denominator.s1.rv$x.min = denominator.s1.rv$x
     let numerator.s1.si.min = numerator.s1.rv$x
     let numerator.s1.si.max = numerator.s1.si.min
     let denominator.s1.si.min = max(numerator.s1.rv$x, denominator.s1.rv$x.loop_min)
     let denominator.s1.si.max = min(numerator.s1.rv$x, denominator.s1.rv$x.loop_max)
     let denominator.s1.i.min = denominator.s1.i.loop_min
     let denominator.s1.i.max = (denominator.s1.i.loop_extent + denominator.s1.i.loop_min) - 1
     let denominator_inter.s1.vis.max = denominator.s1.rv$x.max
     let denominator_inter.s1.vis.min = denominator.s1.rv$x.min
     let denominator_inter.s1.i.max = denominator.s1.i.max
     let denominator_inter.s1.i.min = denominator.s1.i.min
     let denominator_inter.s0.vis.max = denominator_inter.s1.vis.max
     let denominator_inter.s0.vis.min = denominator_inter.s1.vis.min
     let denominator_inter.s0.i.max = denominator.s1.i.max
     let denominator_inter.s0.i.min = denominator.s1.i.min
     if ((uint1)likely(numerator.s1.rv$x >= numerator.s1.rv$x.loop_min)) {
      if ((uint1)likely(numerator.s1.rv$x <= numerator.s1.rv$x.loop_max)) {
       numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
      }
     }
     let denominator.s1.fused.rv$x.loop_extent = 1
     let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
     for (denominator.s1.fused.rv$x, denominator.s1.fused.rv$x.loop_min, denominator.s1.fused.rv$x.loop_extent) {
      for (denominator.s1.i, denominator.s1.i.loop_min, denominator.s1.i.loop_extent) {
       if ((uint1)likely(denominator.s1.fused.rv$x >= denominator.s1.rv$x.loop_min)) {
        if ((uint1)likely(denominator.s1.fused.rv$x <= denominator.s1.rv$x.loop_max)) {
         let denominator.s1.rv$x.max = denominator.s1.rv$x
         let denominator.s1.rv$x.min = denominator.s1.rv$x
         let denominator.s1.si.min = denominator.s1.fused.rv$x
         let denominator.s1.si.max = denominator.s1.si.min
         let denominator.s1.i.min = denominator.s1.i
         let denominator.s1.i.max = denominator.s1.i.min
         let denominator_inter.s1.vis.max = denominator.s1.rv$x.max
         let denominator_inter.s1.vis.min = denominator.s1.rv$x.min
         let denominator_inter.s1.i.max = denominator.s1.i.max
         let denominator_inter.s1.i.min = denominator.s1.i.min
         let denominator_inter.s0.vis.max = denominator_inter.s1.vis.max
         let denominator_inter.s0.vis.min = denominator_inter.s1.vis.min
         let denominator_inter.s0.i.max = denominator.s1.i.max
         let denominator_inter.s0.i.min = denominator.s1.i.min
         realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
          produce denominator_inter {
           let denominator_inter.s0.vis.loop_max = denominator_inter.s0.vis.max
           let denominator_inter.s0.vis.loop_min = denominator_inter.s0.vis.min
           let denominator_inter.s0.vis.loop_extent = (denominator_inter.s0.vis.max + 1) - denominator_inter.s0.vis.min
           let denominator_inter.s0.i.loop_max = denominator_inter.s0.i.max
           let denominator_inter.s0.i.loop_min = denominator_inter.s0.i.min
           let denominator_inter.s0.i.loop_extent = (denominator_inter.s0.i.max + 1) - denominator_inter.s0.i.min
           let denominator_inter.s1.vis.loop_max = denominator_inter.s1.vis.max
           let denominator_inter.s1.vis.loop_min = denominator_inter.s1.vis.min
           let denominator_inter.s1.vis.loop_extent = (denominator_inter.s1.vis.max + 1) - denominator_inter.s1.vis.min
           let denominator_inter.s1.i.loop_max = denominator_inter.s1.i.max
           let denominator_inter.s1.i.loop_min = denominator_inter.s1.i.min
           let denominator_inter.s1.i.loop_extent = (denominator_inter.s1.i.max + 1) - denominator_inter.s1.i.min
           for (denominator_inter.s0.vis, denominator_inter.s0.vis.loop_min, denominator_inter.s0.vis.loop_extent) {
            for (denominator_inter.s0.i, denominator_inter.s0.i.loop_min, denominator_inter.s0.i.loop_extent) {
             denominator_inter(denominator_inter.s0.i, denominator_inter.s0.vis) = 0
            }
           }
           for (denominator_inter.s1.vis, denominator_inter.s1.vis.loop_min, denominator_inter.s1.vis.loop_extent) {
            denominator_inter(0, denominator_inter.s1.vis) = 0 + denominator_inter.s1.vis
           }
          }
          consume denominator_inter {
           denominator(denominator.s1.i, denominator.s1.fused.rv$x) = denominator(denominator.s1.i, denominator.s1.fused.rv$x) + denominator_inter(denominator.s1.i, denominator.s1.fused.rv$x)
          }
         }
        }
       }
      }
     }
    }
   }
  }
  consume numerator {
   consume denominator {
    produce next {
     let next.s0.si.loop_max = next.s0.si.max
     let next.s0.si.loop_min = next.s0.si.min
     let next.s0.si.loop_extent = (next.s0.si.max + 1) - next.s0.si.min
     for (next.s0.si, next.s0.si.loop_min, next.s0.si.loop_extent) {
      next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
     }
    }
   }
  }
 }
}

Removing extern loops...
Lowering after removing extern loops: (unchanged)

Performing sliding window optimization...
Lowering after sliding window:
let next.s0.si.max = (next.min.0 + next.extent.0) - 1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = (10 + 0) - 1
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = next.s0.si.max
let numerator.s1.si.min = next.s0.si.min
let numerator.s0.si.max = max(next.s0.si.max, numerator.s1.rv$x.max)
let numerator.s0.si.min = min(next.s0.si.min, numerator.s1.rv$x.min)
let denominator.s1.rv$x.max = (10 + 0) - 1
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = next.s0.si.max
let denominator.s1.si.min = next.s0.si.min
let denominator.s1.i.max = 0
let denominator.s1.i.min = denominator.s1.i.max
let denominator.s0.si.max = max(denominator.s1.rv$x.max, next.s0.si.max)
let denominator.s0.si.min = min(denominator.s1.rv$x.min, next.s0.si.min)
let denominator.s0.i.max = denominator.s1.i.max
let denominator.s0.i.min = denominator.s1.i.min
let denominator_inter.s1.vis.max = denominator.s1.rv$x.max
let denominator_inter.s1.vis.min = denominator.s1.rv$x.min
let denominator_inter.s1.i.max = denominator.s1.i.max
let denominator_inter.s1.i.min = denominator.s1.i.min
let denominator_inter.s0.vis.max = denominator_inter.s1.vis.max
let denominator_inter.s0.vis.min = denominator_inter.s1.vis.min
let denominator_inter.s0.i.max = denominator.s1.i.max
let denominator_inter.s0.i.min = denominator.s1.i.min
add_image_checks_marker()
realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
 realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
  produce numerator {
   produce denominator {
    let denominator.s0.si.loop_max = denominator.s0.si.max
    let denominator.s0.si.loop_min = denominator.s0.si.min
    let denominator.s0.si.loop_extent = (denominator.s0.si.max + 1) - denominator.s0.si.min
    let denominator.s0.i.loop_max = denominator.s0.i.max
    let denominator.s0.i.loop_min = denominator.s0.i.min
    let denominator.s0.i.loop_extent = (denominator.s0.i.max + 1) - denominator.s0.i.min
    let numerator.s0.si.loop_max = numerator.s0.si.max
    let numerator.s0.si.loop_min = numerator.s0.si.min
    let numerator.s0.si.loop_extent = (numerator.s0.si.max + 1) - numerator.s0.si.min
    let numerator.s1.rv$x.loop_extent = (numerator.s1.rv$x.max - numerator.s1.rv$x.min) + 1
    let numerator.s1.rv$x.loop_max = numerator.s1.rv$x.max
    let numerator.s1.rv$x.loop_min = numerator.s1.rv$x.min
    let numerator.s1.si.loop_max = numerator.s1.si.max
    let numerator.s1.si.loop_min = numerator.s1.si.min
    let numerator.s1.si.loop_extent = (numerator.s1.si.max + 1) - numerator.s1.si.min
    let denominator.s1.rv$x.loop_extent = (denominator.s1.rv$x.max - denominator.s1.rv$x.min) + 1
    let denominator.s1.rv$x.loop_max = denominator.s1.rv$x.max
    let denominator.s1.rv$x.loop_min = denominator.s1.rv$x.min
    let denominator.s1.si.loop_max = denominator.s1.si.max
    let denominator.s1.si.loop_min = denominator.s1.si.min
    let denominator.s1.si.loop_extent = (denominator.s1.si.max + 1) - denominator.s1.si.min
    let denominator.s1.i.loop_max = denominator.s1.i.max
    let denominator.s1.i.loop_min = denominator.s1.i.min
    let denominator.s1.i.loop_extent = (denominator.s1.i.max + 1) - denominator.s1.i.min
    let denominator.s0.si.loop_min.orig = denominator.s0.si.loop_min
    for (denominator.s0.si, denominator.s0.si.loop_min, denominator.s0.si.loop_extent) {
     let denominator.s0.i.loop_min.orig = denominator.s0.i.loop_min
     for (denominator.s0.i, denominator.s0.i.loop_min, denominator.s0.i.loop_extent) {
      denominator(denominator.s0.i, denominator.s0.si) = 0
     }
    }
    let numerator.s0.si.loop_min.orig = numerator.s0.si.loop_min
    for (numerator.s0.si, numerator.s0.si.loop_min, numerator.s0.si.loop_extent) {
     numerator(numerator.s0.si) = 0
    }
    let numerator.s1.rv$x.loop_min.orig = numerator.s1.rv$x.loop_min
    for (numerator.s1.rv$x, numerator.s1.rv$x.loop_min, numerator.s1.rv$x.loop_extent) {
     let numerator.s1.rv$x.max = numerator.s1.rv$x
     let numerator.s1.rv$x.min = numerator.s1.rv$x
     let denominator.s1.rv$x.max = denominator.s1.rv$x
     let denominator.s1.rv$x.min = denominator.s1.rv$x
     let numerator.s1.si.min = numerator.s1.rv$x
     let numerator.s1.si.max = numerator.s1.si.min
     let denominator.s1.si.min = max(numerator.s1.rv$x, denominator.s1.rv$x.loop_min)
     let denominator.s1.si.max = min(numerator.s1.rv$x, denominator.s1.rv$x.loop_max)
     let denominator.s1.i.min = denominator.s1.i.loop_min
     let denominator.s1.i.max = (denominator.s1.i.loop_extent + denominator.s1.i.loop_min) - 1
     let denominator_inter.s1.vis.max = denominator.s1.rv$x.max
     let denominator_inter.s1.vis.min = denominator.s1.rv$x.min
     let denominator_inter.s1.i.max = denominator.s1.i.max
     let denominator_inter.s1.i.min = denominator.s1.i.min
     let denominator_inter.s0.vis.max = denominator_inter.s1.vis.max
     let denominator_inter.s0.vis.min = denominator_inter.s1.vis.min
     let denominator_inter.s0.i.max = denominator.s1.i.max
     let denominator_inter.s0.i.min = denominator.s1.i.min
     if ((uint1)likely(numerator.s1.rv$x >= numerator.s1.rv$x.loop_min)) {
      if ((uint1)likely(numerator.s1.rv$x <= numerator.s1.rv$x.loop_max)) {
       numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
      }
     }
     let denominator.s1.fused.rv$x.loop_extent = 1
     let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_min.orig = denominator.s1.fused.rv$x.loop_min
     for (denominator.s1.fused.rv$x, denominator.s1.fused.rv$x.loop_min, denominator.s1.fused.rv$x.loop_extent) {
      let denominator.s1.i.loop_min.orig = denominator.s1.i.loop_min
      for (denominator.s1.i, denominator.s1.i.loop_min, denominator.s1.i.loop_extent) {
       if ((uint1)likely(denominator.s1.fused.rv$x >= denominator.s1.rv$x.loop_min)) {
        if ((uint1)likely(denominator.s1.fused.rv$x <= denominator.s1.rv$x.loop_max)) {
         let denominator.s1.rv$x.max = denominator.s1.rv$x
         let denominator.s1.rv$x.min = denominator.s1.rv$x
         let denominator.s1.si.min = denominator.s1.fused.rv$x
         let denominator.s1.si.max = denominator.s1.si.min
         let denominator.s1.i.min = denominator.s1.i
         let denominator.s1.i.max = denominator.s1.i.min
         let denominator_inter.s1.vis.max = denominator.s1.rv$x.max
         let denominator_inter.s1.vis.min = denominator.s1.rv$x.min
         let denominator_inter.s1.i.max = denominator.s1.i.max
         let denominator_inter.s1.i.min = denominator.s1.i.min
         let denominator_inter.s0.vis.max = denominator_inter.s1.vis.max
         let denominator_inter.s0.vis.min = denominator_inter.s1.vis.min
         let denominator_inter.s0.i.max = denominator.s1.i.max
         let denominator_inter.s0.i.min = denominator.s1.i.min
         realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
          produce denominator_inter {
           let denominator_inter.s0.vis.loop_max = denominator_inter.s0.vis.max
           let denominator_inter.s0.vis.loop_min = denominator_inter.s0.vis.min
           let denominator_inter.s0.vis.loop_extent = (denominator_inter.s0.vis.max + 1) - denominator_inter.s0.vis.min
           let denominator_inter.s0.i.loop_max = denominator_inter.s0.i.max
           let denominator_inter.s0.i.loop_min = denominator_inter.s0.i.min
           let denominator_inter.s0.i.loop_extent = (denominator_inter.s0.i.max + 1) - denominator_inter.s0.i.min
           let denominator_inter.s1.vis.loop_max = denominator_inter.s1.vis.max
           let denominator_inter.s1.vis.loop_min = denominator_inter.s1.vis.min
           let denominator_inter.s1.vis.loop_extent = (denominator_inter.s1.vis.max + 1) - denominator_inter.s1.vis.min
           let denominator_inter.s1.i.loop_max = denominator_inter.s1.i.max
           let denominator_inter.s1.i.loop_min = denominator_inter.s1.i.min
           let denominator_inter.s1.i.loop_extent = (denominator_inter.s1.i.max + 1) - denominator_inter.s1.i.min
           let denominator_inter.s0.vis.loop_min.orig = denominator_inter.s0.vis.loop_min
           for (denominator_inter.s0.vis, denominator_inter.s0.vis.loop_min, denominator_inter.s0.vis.loop_extent) {
            let denominator_inter.s0.i.loop_min.orig = denominator_inter.s0.i.loop_min
            for (denominator_inter.s0.i, denominator_inter.s0.i.loop_min, denominator_inter.s0.i.loop_extent) {
             denominator_inter(denominator_inter.s0.i, denominator_inter.s0.vis) = 0
            }
           }
           let denominator_inter.s1.vis.loop_min.orig = denominator_inter.s1.vis.loop_min
           for (denominator_inter.s1.vis, denominator_inter.s1.vis.loop_min, denominator_inter.s1.vis.loop_extent) {
            denominator_inter(0, denominator_inter.s1.vis) = 0 + denominator_inter.s1.vis
           }
          }
          consume denominator_inter {
           denominator(denominator.s1.i, denominator.s1.fused.rv$x) = denominator(denominator.s1.i, denominator.s1.fused.rv$x) + denominator_inter(denominator.s1.i, denominator.s1.fused.rv$x)
          }
         }
        }
       }
      }
     }
    }
   }
  }
  consume numerator {
   consume denominator {
    produce next {
     let next.s0.si.loop_max = next.s0.si.max
     let next.s0.si.loop_min = next.s0.si.min
     let next.s0.si.loop_extent = (next.s0.si.max + 1) - next.s0.si.min
     let next.s0.si.loop_min.orig = next.s0.si.loop_min
     for (next.s0.si, next.s0.si.loop_min, next.s0.si.loop_extent) {
      next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
     }
    }
   }
  }
 }
}

Uniquifying variable names...
Lowering after uniquifying variable names:
let next.s0.si.max = (next.min.0 + next.extent.0) - 1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = (10 + 0) - 1
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = next.s0.si.max
let numerator.s1.si.min = next.s0.si.min
let numerator.s0.si.max = max(next.s0.si.max, numerator.s1.rv$x.max)
let numerator.s0.si.min = min(next.s0.si.min, numerator.s1.rv$x.min)
let denominator.s1.rv$x.max = (10 + 0) - 1
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = next.s0.si.max
let denominator.s1.si.min = next.s0.si.min
let denominator.s1.i.max = 0
let denominator.s1.i.min = denominator.s1.i.max
let denominator.s0.si.max = max(denominator.s1.rv$x.max, next.s0.si.max)
let denominator.s0.si.min = min(denominator.s1.rv$x.min, next.s0.si.min)
let denominator.s0.i.max = denominator.s1.i.max
let denominator.s0.i.min = denominator.s1.i.min
let denominator_inter.s1.vis.max = denominator.s1.rv$x.max
let denominator_inter.s1.vis.min = denominator.s1.rv$x.min
let denominator_inter.s1.i.max = denominator.s1.i.max
let denominator_inter.s1.i.min = denominator.s1.i.min
let denominator_inter.s0.vis.max = denominator_inter.s1.vis.max
let denominator_inter.s0.vis.min = denominator_inter.s1.vis.min
let denominator_inter.s0.i.max = denominator.s1.i.max
let denominator_inter.s0.i.min = denominator.s1.i.min
add_image_checks_marker()
realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
 realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
  produce numerator {
   produce denominator {
    let denominator.s0.si.loop_max = denominator.s0.si.max
    let denominator.s0.si.loop_min = denominator.s0.si.min
    let denominator.s0.si.loop_extent = (denominator.s0.si.max + 1) - denominator.s0.si.min
    let denominator.s0.i.loop_max = denominator.s0.i.max
    let denominator.s0.i.loop_min = denominator.s0.i.min
    let denominator.s0.i.loop_extent = (denominator.s0.i.max + 1) - denominator.s0.i.min
    let numerator.s0.si.loop_max = numerator.s0.si.max
    let numerator.s0.si.loop_min = numerator.s0.si.min
    let numerator.s0.si.loop_extent = (numerator.s0.si.max + 1) - numerator.s0.si.min
    let numerator.s1.rv$x.loop_extent = (numerator.s1.rv$x.max - numerator.s1.rv$x.min) + 1
    let numerator.s1.rv$x.loop_max = numerator.s1.rv$x.max
    let numerator.s1.rv$x.loop_min = numerator.s1.rv$x.min
    let numerator.s1.si.loop_max = numerator.s1.si.max
    let numerator.s1.si.loop_min = numerator.s1.si.min
    let numerator.s1.si.loop_extent = (numerator.s1.si.max + 1) - numerator.s1.si.min
    let denominator.s1.rv$x.loop_extent = (denominator.s1.rv$x.max - denominator.s1.rv$x.min) + 1
    let denominator.s1.rv$x.loop_max = denominator.s1.rv$x.max
    let denominator.s1.rv$x.loop_min = denominator.s1.rv$x.min
    let denominator.s1.si.loop_max = denominator.s1.si.max
    let denominator.s1.si.loop_min = denominator.s1.si.min
    let denominator.s1.si.loop_extent = (denominator.s1.si.max + 1) - denominator.s1.si.min
    let denominator.s1.i.loop_max = denominator.s1.i.max
    let denominator.s1.i.loop_min = denominator.s1.i.min
    let denominator.s1.i.loop_extent = (denominator.s1.i.max + 1) - denominator.s1.i.min
    let denominator.s0.si.loop_min.orig = denominator.s0.si.loop_min
    for (denominator.s0.si, denominator.s0.si.loop_min, denominator.s0.si.loop_extent) {
     let denominator.s0.i.loop_min.orig = denominator.s0.i.loop_min
     for (denominator.s0.i, denominator.s0.i.loop_min, denominator.s0.i.loop_extent) {
      denominator(denominator.s0.i, denominator.s0.si) = 0
     }
    }
    let numerator.s0.si.loop_min.orig = numerator.s0.si.loop_min
    for (numerator.s0.si, numerator.s0.si.loop_min, numerator.s0.si.loop_extent) {
     numerator(numerator.s0.si) = 0
    }
    let numerator.s1.rv$x.loop_min.orig = numerator.s1.rv$x.loop_min
    for (numerator.s1.rv$x, numerator.s1.rv$x.loop_min, numerator.s1.rv$x.loop_extent) {
     let numerator.s1.rv$x.max_1 = numerator.s1.rv$x
     let numerator.s1.rv$x.min_1 = numerator.s1.rv$x
     let denominator.s1.rv$x.max_1 = denominator.s1.rv$x
     let denominator.s1.rv$x.min_1 = denominator.s1.rv$x
     let numerator.s1.si.min_1 = numerator.s1.rv$x
     let numerator.s1.si.max_1 = numerator.s1.si.min_1
     let denominator.s1.si.min_1 = max(numerator.s1.rv$x, denominator.s1.rv$x.loop_min)
     let denominator.s1.si.max_1 = min(numerator.s1.rv$x, denominator.s1.rv$x.loop_max)
     let denominator.s1.i.min_1 = denominator.s1.i.loop_min
     let denominator.s1.i.max_1 = (denominator.s1.i.loop_extent + denominator.s1.i.loop_min) - 1
     let denominator_inter.s1.vis.max_1 = denominator.s1.rv$x.max_1
     let denominator_inter.s1.vis.min_1 = denominator.s1.rv$x.min_1
     let denominator_inter.s1.i.max_1 = denominator.s1.i.max_1
     let denominator_inter.s1.i.min_1 = denominator.s1.i.min_1
     let denominator_inter.s0.vis.max_1 = denominator_inter.s1.vis.max_1
     let denominator_inter.s0.vis.min_1 = denominator_inter.s1.vis.min_1
     let denominator_inter.s0.i.max_1 = denominator.s1.i.max_1
     let denominator_inter.s0.i.min_1 = denominator.s1.i.min_1
     if ((uint1)likely(numerator.s1.rv$x >= numerator.s1.rv$x.loop_min)) {
      if ((uint1)likely(numerator.s1.rv$x <= numerator.s1.rv$x.loop_max)) {
       numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
      }
     }
     let denominator.s1.fused.rv$x.loop_extent = 1
     let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_min.orig = denominator.s1.fused.rv$x.loop_min
     for (denominator.s1.fused.rv$x, denominator.s1.fused.rv$x.loop_min, denominator.s1.fused.rv$x.loop_extent) {
      let denominator.s1.i.loop_min.orig = denominator.s1.i.loop_min
      for (denominator.s1.i, denominator.s1.i.loop_min, denominator.s1.i.loop_extent) {
       if ((uint1)likely(denominator.s1.fused.rv$x >= denominator.s1.rv$x.loop_min)) {
        if ((uint1)likely(denominator.s1.fused.rv$x <= denominator.s1.rv$x.loop_max)) {
         let denominator.s1.rv$x.max_2 = denominator.s1.rv$x
         let denominator.s1.rv$x.min_2 = denominator.s1.rv$x
         let denominator.s1.si.min_2 = denominator.s1.fused.rv$x
         let denominator.s1.si.max_2 = denominator.s1.si.min_2
         let denominator.s1.i.min_2 = denominator.s1.i
         let denominator.s1.i.max_2 = denominator.s1.i.min_2
         let denominator_inter.s1.vis.max_2 = denominator.s1.rv$x.max_2
         let denominator_inter.s1.vis.min_2 = denominator.s1.rv$x.min_2
         let denominator_inter.s1.i.max_2 = denominator.s1.i.max_2
         let denominator_inter.s1.i.min_2 = denominator.s1.i.min_2
         let denominator_inter.s0.vis.max_2 = denominator_inter.s1.vis.max_2
         let denominator_inter.s0.vis.min_2 = denominator_inter.s1.vis.min_2
         let denominator_inter.s0.i.max_2 = denominator.s1.i.max_2
         let denominator_inter.s0.i.min_2 = denominator.s1.i.min_2
         realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
          produce denominator_inter {
           let denominator_inter.s0.vis.loop_max = denominator_inter.s0.vis.max_2
           let denominator_inter.s0.vis.loop_min = denominator_inter.s0.vis.min_2
           let denominator_inter.s0.vis.loop_extent = (denominator_inter.s0.vis.max_2 + 1) - denominator_inter.s0.vis.min_2
           let denominator_inter.s0.i.loop_max = denominator_inter.s0.i.max_2
           let denominator_inter.s0.i.loop_min = denominator_inter.s0.i.min_2
           let denominator_inter.s0.i.loop_extent = (denominator_inter.s0.i.max_2 + 1) - denominator_inter.s0.i.min_2
           let denominator_inter.s1.vis.loop_max = denominator_inter.s1.vis.max_2
           let denominator_inter.s1.vis.loop_min = denominator_inter.s1.vis.min_2
           let denominator_inter.s1.vis.loop_extent = (denominator_inter.s1.vis.max_2 + 1) - denominator_inter.s1.vis.min_2
           let denominator_inter.s1.i.loop_max = denominator_inter.s1.i.max_2
           let denominator_inter.s1.i.loop_min = denominator_inter.s1.i.min_2
           let denominator_inter.s1.i.loop_extent = (denominator_inter.s1.i.max_2 + 1) - denominator_inter.s1.i.min_2
           let denominator_inter.s0.vis.loop_min.orig = denominator_inter.s0.vis.loop_min
           for (denominator_inter.s0.vis, denominator_inter.s0.vis.loop_min, denominator_inter.s0.vis.loop_extent) {
            let denominator_inter.s0.i.loop_min.orig = denominator_inter.s0.i.loop_min
            for (denominator_inter.s0.i, denominator_inter.s0.i.loop_min, denominator_inter.s0.i.loop_extent) {
             denominator_inter(denominator_inter.s0.i, denominator_inter.s0.vis) = 0
            }
           }
           let denominator_inter.s1.vis.loop_min.orig = denominator_inter.s1.vis.loop_min
           for (denominator_inter.s1.vis, denominator_inter.s1.vis.loop_min, denominator_inter.s1.vis.loop_extent) {
            denominator_inter(0, denominator_inter.s1.vis) = 0 + denominator_inter.s1.vis
           }
          }
          consume denominator_inter {
           denominator(denominator.s1.i, denominator.s1.fused.rv$x) = denominator(denominator.s1.i, denominator.s1.fused.rv$x) + denominator_inter(denominator.s1.i, denominator.s1.fused.rv$x)
          }
         }
        }
       }
      }
     }
    }
   }
  }
  consume numerator {
   consume denominator {
    produce next {
     let next.s0.si.loop_max = next.s0.si.max
     let next.s0.si.loop_min = next.s0.si.min
     let next.s0.si.loop_extent = (next.s0.si.max + 1) - next.s0.si.min
     let next.s0.si.loop_min.orig = next.s0.si.loop_min
     for (next.s0.si, next.s0.si.loop_min, next.s0.si.loop_extent) {
      next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
     }
    }
   }
  }
 }
}

Simplifying...
Lowering after first simplification:
let next.s0.si.max = (next.extent.0 + next.min.0) + -1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = 9
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = (next.extent.0 + next.min.0) + -1
let numerator.s1.si.min = next.min.0
let numerator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let numerator.s0.si.min = min(next.min.0, 0)
let denominator.s1.rv$x.max = 9
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = (next.extent.0 + next.min.0) + -1
let denominator.s1.si.min = next.min.0
let denominator.s1.i.max = 0
let denominator.s1.i.min = 0
let denominator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let denominator.s0.si.min = min(next.min.0, 0)
let denominator.s0.i.max = 0
let denominator.s0.i.min = 0
let denominator_inter.s1.vis.max = 9
let denominator_inter.s1.vis.min = 0
let denominator_inter.s1.i.max = 0
let denominator_inter.s1.i.min = 0
let denominator_inter.s0.vis.max = 9
let denominator_inter.s0.vis.min = 0
let denominator_inter.s0.i.max = 0
let denominator_inter.s0.i.min = 0
add_image_checks_marker()
realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
 realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
  produce numerator {
   produce denominator {
    let denominator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
    let denominator.s0.si.loop_min = min(next.min.0, 0)
    let denominator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
    let denominator.s0.i.loop_max = 0
    let denominator.s0.i.loop_min = 0
    let denominator.s0.i.loop_extent = 1
    let numerator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
    let numerator.s0.si.loop_min = min(next.min.0, 0)
    let numerator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
    let numerator.s1.rv$x.loop_extent = 10
    let numerator.s1.rv$x.loop_max = 9
    let numerator.s1.rv$x.loop_min = 0
    let numerator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
    let numerator.s1.si.loop_min = next.min.0
    let numerator.s1.si.loop_extent = next.extent.0
    let denominator.s1.rv$x.loop_extent = 10
    let denominator.s1.rv$x.loop_max = 9
    let denominator.s1.rv$x.loop_min = 0
    let denominator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
    let denominator.s1.si.loop_min = next.min.0
    let denominator.s1.si.loop_extent = next.extent.0
    let denominator.s1.i.loop_max = 0
    let denominator.s1.i.loop_min = 0
    let denominator.s1.i.loop_extent = 1
    let denominator.s0.si.loop_min.orig = min(next.min.0, 0)
    for (denominator.s0.si, min(next.min.0, 0), denominator.s0.si.loop_extent) {
     let denominator.s0.i.loop_min.orig = 0
     let denominator.s0.i = 0
     denominator(0, denominator.s0.si) = 0
    }
    let numerator.s0.si.loop_min.orig = min(next.min.0, 0)
    for (numerator.s0.si, min(next.min.0, 0), numerator.s0.si.loop_extent) {
     numerator(numerator.s0.si) = 0
    }
    let numerator.s1.rv$x.loop_min.orig = 0
    for (numerator.s1.rv$x, 0, 10) {
     let numerator.s1.rv$x.max_1 = numerator.s1.rv$x
     let numerator.s1.rv$x.min_1 = numerator.s1.rv$x
     let denominator.s1.rv$x.max_1 = denominator.s1.rv$x
     let denominator.s1.rv$x.min_1 = denominator.s1.rv$x
     let numerator.s1.si.min_1 = numerator.s1.rv$x
     let numerator.s1.si.max_1 = numerator.s1.rv$x
     let denominator.s1.si.min_1 = numerator.s1.rv$x
     let denominator.s1.si.max_1 = numerator.s1.rv$x
     let denominator.s1.i.min_1 = 0
     let denominator.s1.i.max_1 = 0
     let denominator_inter.s1.vis.max_1 = denominator.s1.rv$x
     let denominator_inter.s1.vis.min_1 = denominator.s1.rv$x
     let denominator_inter.s1.i.max_1 = 0
     let denominator_inter.s1.i.min_1 = 0
     let denominator_inter.s0.vis.max_1 = denominator.s1.rv$x
     let denominator_inter.s0.vis.min_1 = denominator.s1.rv$x
     let denominator_inter.s0.i.max_1 = 0
     let denominator_inter.s0.i.min_1 = 0
     numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_extent = 1
     let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_min.orig = numerator.s1.rv$x
     let denominator.s1.fused.rv$x = numerator.s1.rv$x
     let denominator.s1.i.loop_min.orig = 0
     let denominator.s1.i = 0
     let denominator.s1.rv$x.max_2 = denominator.s1.rv$x
     let denominator.s1.rv$x.min_2 = denominator.s1.rv$x
     let denominator.s1.si.min_2 = numerator.s1.rv$x
     let denominator.s1.si.max_2 = numerator.s1.rv$x
     let denominator.s1.i.min_2 = 0
     let denominator.s1.i.max_2 = 0
     let denominator_inter.s1.vis.max_2 = denominator.s1.rv$x
     let denominator_inter.s1.vis.min_2 = denominator.s1.rv$x
     let denominator_inter.s1.i.max_2 = 0
     let denominator_inter.s1.i.min_2 = 0
     let denominator_inter.s0.vis.max_2 = denominator.s1.rv$x
     let denominator_inter.s0.vis.min_2 = denominator.s1.rv$x
     let denominator_inter.s0.i.max_2 = 0
     let denominator_inter.s0.i.min_2 = 0
     realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
      produce denominator_inter {
       let denominator_inter.s0.vis.loop_max = denominator.s1.rv$x
       let denominator_inter.s0.vis.loop_min = denominator.s1.rv$x
       let denominator_inter.s0.vis.loop_extent = 1
       let denominator_inter.s0.i.loop_max = 0
       let denominator_inter.s0.i.loop_min = 0
       let denominator_inter.s0.i.loop_extent = 1
       let denominator_inter.s1.vis.loop_max = denominator.s1.rv$x
       let denominator_inter.s1.vis.loop_min = denominator.s1.rv$x
       let denominator_inter.s1.vis.loop_extent = 1
       let denominator_inter.s1.i.loop_max = 0
       let denominator_inter.s1.i.loop_min = 0
       let denominator_inter.s1.i.loop_extent = 1
       let t4 = denominator.s1.rv$x
       let t3 = denominator.s1.rv$x
       let denominator_inter.s0.i.loop_min.orig = 0
       let denominator_inter.s0.i = 0
       denominator_inter(0, denominator.s1.rv$x) = 0
       denominator_inter(0, denominator.s1.rv$x) = denominator.s1.rv$x
      }
      consume denominator_inter {
       denominator(0, numerator.s1.rv$x) = denominator(0, numerator.s1.rv$x) + denominator_inter(0, numerator.s1.rv$x)
      }
     }
    }
   }
  }
  consume numerator {
   consume denominator {
    produce next {
     let next.s0.si.loop_max = (next.extent.0 + next.min.0) + -1
     let next.s0.si.loop_min = next.min.0
     let next.s0.si.loop_extent = next.extent.0
     let next.s0.si.loop_min.orig = next.min.0
     for (next.s0.si, next.min.0, next.extent.0) {
      next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
     }
    }
   }
  }
 }
}

Simplifying correlated differences...
Lowering after simplifying correlated differences:
let next.s0.si.max = (next.extent.0 + next.min.0) + -1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = 9
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = (next.extent.0 + next.min.0) + -1
let numerator.s1.si.min = next.min.0
let numerator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let numerator.s0.si.min = min(next.min.0, 0)
let denominator.s1.rv$x.max = 9
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = (next.extent.0 + next.min.0) + -1
let denominator.s1.si.min = next.min.0
let denominator.s1.i.max = 0
let denominator.s1.i.min = 0
let denominator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let denominator.s0.si.min = min(next.min.0, 0)
let denominator.s0.i.max = 0
let denominator.s0.i.min = 0
let denominator_inter.s1.vis.max = 9
let denominator_inter.s1.vis.min = 0
let denominator_inter.s1.i.max = 0
let denominator_inter.s1.i.min = 0
let denominator_inter.s0.vis.max = 9
let denominator_inter.s0.vis.min = 0
let denominator_inter.s0.i.max = 0
let denominator_inter.s0.i.min = 0
add_image_checks_marker()
realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
 realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
  produce numerator {
   produce denominator {
    let denominator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
    let denominator.s0.si.loop_min = min(next.min.0, 0)
    let denominator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
    let denominator.s0.i.loop_max = 0
    let denominator.s0.i.loop_min = 0
    let denominator.s0.i.loop_extent = 1
    let numerator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
    let numerator.s0.si.loop_min = min(next.min.0, 0)
    let numerator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
    let numerator.s1.rv$x.loop_extent = 10
    let numerator.s1.rv$x.loop_max = 9
    let numerator.s1.rv$x.loop_min = 0
    let numerator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
    let numerator.s1.si.loop_min = next.min.0
    let numerator.s1.si.loop_extent = next.extent.0
    let denominator.s1.rv$x.loop_extent = 10
    let denominator.s1.rv$x.loop_max = 9
    let denominator.s1.rv$x.loop_min = 0
    let denominator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
    let denominator.s1.si.loop_min = next.min.0
    let denominator.s1.si.loop_extent = next.extent.0
    let denominator.s1.i.loop_max = 0
    let denominator.s1.i.loop_min = 0
    let denominator.s1.i.loop_extent = 1
    let denominator.s0.si.loop_min.orig = min(next.min.0, 0)
    for (denominator.s0.si, min(next.min.0, 0), denominator.s0.si.loop_extent) {
     let denominator.s0.i.loop_min.orig = 0
     let denominator.s0.i = 0
     denominator(0, denominator.s0.si) = 0
    }
    let numerator.s0.si.loop_min.orig = min(next.min.0, 0)
    for (numerator.s0.si, min(next.min.0, 0), numerator.s0.si.loop_extent) {
     numerator(numerator.s0.si) = 0
    }
    let numerator.s1.rv$x.loop_min.orig = 0
    for (numerator.s1.rv$x, 0, 10) {
     let numerator.s1.rv$x.max_1 = numerator.s1.rv$x
     let numerator.s1.rv$x.min_1 = numerator.s1.rv$x
     let denominator.s1.rv$x.max_1 = denominator.s1.rv$x
     let denominator.s1.rv$x.min_1 = denominator.s1.rv$x
     let numerator.s1.si.min_1 = numerator.s1.rv$x
     let numerator.s1.si.max_1 = numerator.s1.rv$x
     let denominator.s1.si.min_1 = numerator.s1.rv$x
     let denominator.s1.si.max_1 = numerator.s1.rv$x
     let denominator.s1.i.min_1 = 0
     let denominator.s1.i.max_1 = 0
     let denominator_inter.s1.vis.max_1 = denominator.s1.rv$x
     let denominator_inter.s1.vis.min_1 = denominator.s1.rv$x
     let denominator_inter.s1.i.max_1 = 0
     let denominator_inter.s1.i.min_1 = 0
     let denominator_inter.s0.vis.max_1 = denominator.s1.rv$x
     let denominator_inter.s0.vis.min_1 = denominator.s1.rv$x
     let denominator_inter.s0.i.max_1 = 0
     let denominator_inter.s0.i.min_1 = 0
     numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_extent = 1
     let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_min.orig = numerator.s1.rv$x
     let denominator.s1.fused.rv$x = numerator.s1.rv$x
     let denominator.s1.i.loop_min.orig = 0
     let denominator.s1.i = 0
     let denominator.s1.rv$x.max_2 = denominator.s1.rv$x
     let denominator.s1.rv$x.min_2 = denominator.s1.rv$x
     let denominator.s1.si.min_2 = numerator.s1.rv$x
     let denominator.s1.si.max_2 = numerator.s1.rv$x
     let denominator.s1.i.min_2 = 0
     let denominator.s1.i.max_2 = 0
     let denominator_inter.s1.vis.max_2 = denominator.s1.rv$x
     let denominator_inter.s1.vis.min_2 = denominator.s1.rv$x
     let denominator_inter.s1.i.max_2 = 0
     let denominator_inter.s1.i.min_2 = 0
     let denominator_inter.s0.vis.max_2 = denominator.s1.rv$x
     let denominator_inter.s0.vis.min_2 = denominator.s1.rv$x
     let denominator_inter.s0.i.max_2 = 0
     let denominator_inter.s0.i.min_2 = 0
     realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
      produce denominator_inter {
       let denominator_inter.s0.vis.loop_max = denominator.s1.rv$x
       let denominator_inter.s0.vis.loop_min = denominator.s1.rv$x
       let denominator_inter.s0.vis.loop_extent = 1
       let denominator_inter.s0.i.loop_max = 0
       let denominator_inter.s0.i.loop_min = 0
       let denominator_inter.s0.i.loop_extent = 1
       let denominator_inter.s1.vis.loop_max = denominator.s1.rv$x
       let denominator_inter.s1.vis.loop_min = denominator.s1.rv$x
       let denominator_inter.s1.vis.loop_extent = 1
       let denominator_inter.s1.i.loop_max = 0
       let denominator_inter.s1.i.loop_min = 0
       let denominator_inter.s1.i.loop_extent = 1
       let t4 = denominator.s1.rv$x
       let t3 = denominator.s1.rv$x
       let denominator_inter.s0.i.loop_min.orig = 0
       let denominator_inter.s0.i = 0
       denominator_inter(0, denominator.s1.rv$x) = 0
       denominator_inter(0, denominator.s1.rv$x) = denominator.s1.rv$x
      }
      consume denominator_inter {
       denominator(0, numerator.s1.rv$x) = denominator(0, numerator.s1.rv$x) + denominator_inter(0, numerator.s1.rv$x)
      }
     }
    }
   }
  }
  consume numerator {
   consume denominator {
    produce next {
     let next.s0.si.loop_max = (next.extent.0 + next.min.0) + -1
     let next.s0.si.loop_min = next.min.0
     let next.s0.si.loop_extent = next.extent.0
     let next.s0.si.loop_min.orig = next.min.0
     for (next.s0.si, next.min.0, next.extent.0) {
      next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
     }
    }
   }
  }
 }
}

Performing allocation bounds inference...
Lowering after allocation bounds inference:
let next.s0.si.max = (next.extent.0 + next.min.0) + -1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = 9
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = (next.extent.0 + next.min.0) + -1
let numerator.s1.si.min = next.min.0
let numerator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let numerator.s0.si.min = min(next.min.0, 0)
let denominator.s1.rv$x.max = 9
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = (next.extent.0 + next.min.0) + -1
let denominator.s1.si.min = next.min.0
let denominator.s1.i.max = 0
let denominator.s1.i.min = 0
let denominator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let denominator.s0.si.min = min(next.min.0, 0)
let denominator.s0.i.max = 0
let denominator.s0.i.min = 0
let denominator_inter.s1.vis.max = 9
let denominator_inter.s1.vis.min = 0
let denominator_inter.s1.i.max = 0
let denominator_inter.s1.i.min = 0
let denominator_inter.s0.vis.max = 9
let denominator_inter.s0.vis.min = 0
let denominator_inter.s0.i.max = 0
let denominator_inter.s0.i.min = 0
add_image_checks_marker()
let numerator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
let numerator.si.min_realized = min(next.min.0, 0)
let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
 let denominator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
 let denominator.si.min_realized = min(next.min.0, 0)
 let denominator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 let denominator.i.max_realized = 0
 let denominator.i.min_realized = 0
 let denominator.i.extent_realized = 1
 realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
  produce numerator {
   produce denominator {
    let denominator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
    let denominator.s0.si.loop_min = min(next.min.0, 0)
    let denominator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
    let denominator.s0.i.loop_max = 0
    let denominator.s0.i.loop_min = 0
    let denominator.s0.i.loop_extent = 1
    let numerator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
    let numerator.s0.si.loop_min = min(next.min.0, 0)
    let numerator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
    let numerator.s1.rv$x.loop_extent = 10
    let numerator.s1.rv$x.loop_max = 9
    let numerator.s1.rv$x.loop_min = 0
    let numerator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
    let numerator.s1.si.loop_min = next.min.0
    let numerator.s1.si.loop_extent = next.extent.0
    let denominator.s1.rv$x.loop_extent = 10
    let denominator.s1.rv$x.loop_max = 9
    let denominator.s1.rv$x.loop_min = 0
    let denominator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
    let denominator.s1.si.loop_min = next.min.0
    let denominator.s1.si.loop_extent = next.extent.0
    let denominator.s1.i.loop_max = 0
    let denominator.s1.i.loop_min = 0
    let denominator.s1.i.loop_extent = 1
    let denominator.s0.si.loop_min.orig = min(next.min.0, 0)
    for (denominator.s0.si, min(next.min.0, 0), denominator.s0.si.loop_extent) {
     let denominator.s0.i.loop_min.orig = 0
     let denominator.s0.i = 0
     denominator(0, denominator.s0.si) = 0
    }
    let numerator.s0.si.loop_min.orig = min(next.min.0, 0)
    for (numerator.s0.si, min(next.min.0, 0), numerator.s0.si.loop_extent) {
     numerator(numerator.s0.si) = 0
    }
    let numerator.s1.rv$x.loop_min.orig = 0
    for (numerator.s1.rv$x, 0, 10) {
     let numerator.s1.rv$x.max_1 = numerator.s1.rv$x
     let numerator.s1.rv$x.min_1 = numerator.s1.rv$x
     let denominator.s1.rv$x.max_1 = denominator.s1.rv$x
     let denominator.s1.rv$x.min_1 = denominator.s1.rv$x
     let numerator.s1.si.min_1 = numerator.s1.rv$x
     let numerator.s1.si.max_1 = numerator.s1.rv$x
     let denominator.s1.si.min_1 = numerator.s1.rv$x
     let denominator.s1.si.max_1 = numerator.s1.rv$x
     let denominator.s1.i.min_1 = 0
     let denominator.s1.i.max_1 = 0
     let denominator_inter.s1.vis.max_1 = denominator.s1.rv$x
     let denominator_inter.s1.vis.min_1 = denominator.s1.rv$x
     let denominator_inter.s1.i.max_1 = 0
     let denominator_inter.s1.i.min_1 = 0
     let denominator_inter.s0.vis.max_1 = denominator.s1.rv$x
     let denominator_inter.s0.vis.min_1 = denominator.s1.rv$x
     let denominator_inter.s0.i.max_1 = 0
     let denominator_inter.s0.i.min_1 = 0
     numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_extent = 1
     let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
     let denominator.s1.fused.rv$x.loop_min.orig = numerator.s1.rv$x
     let denominator.s1.fused.rv$x = numerator.s1.rv$x
     let denominator.s1.i.loop_min.orig = 0
     let denominator.s1.i = 0
     let denominator.s1.rv$x.max_2 = denominator.s1.rv$x
     let denominator.s1.rv$x.min_2 = denominator.s1.rv$x
     let denominator.s1.si.min_2 = numerator.s1.rv$x
     let denominator.s1.si.max_2 = numerator.s1.rv$x
     let denominator.s1.i.min_2 = 0
     let denominator.s1.i.max_2 = 0
     let denominator_inter.s1.vis.max_2 = denominator.s1.rv$x
     let denominator_inter.s1.vis.min_2 = denominator.s1.rv$x
     let denominator_inter.s1.i.max_2 = 0
     let denominator_inter.s1.i.min_2 = 0
     let denominator_inter.s0.vis.max_2 = denominator.s1.rv$x
     let denominator_inter.s0.vis.min_2 = denominator.s1.rv$x
     let denominator_inter.s0.i.max_2 = 0
     let denominator_inter.s0.i.min_2 = 0
     let denominator_inter.vis.max_realized = max(denominator.s1.rv$x, numerator.s1.rv$x)
     let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
     let denominator_inter.vis.extent_realized = (max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)) + 1
     let denominator_inter.i.max_realized = 0
     let denominator_inter.i.min_realized = 0
     let denominator_inter.i.extent_realized = 1
     realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
      produce denominator_inter {
       let denominator_inter.s0.vis.loop_max = denominator.s1.rv$x
       let denominator_inter.s0.vis.loop_min = denominator.s1.rv$x
       let denominator_inter.s0.vis.loop_extent = 1
       let denominator_inter.s0.i.loop_max = 0
       let denominator_inter.s0.i.loop_min = 0
       let denominator_inter.s0.i.loop_extent = 1
       let denominator_inter.s1.vis.loop_max = denominator.s1.rv$x
       let denominator_inter.s1.vis.loop_min = denominator.s1.rv$x
       let denominator_inter.s1.vis.loop_extent = 1
       let denominator_inter.s1.i.loop_max = 0
       let denominator_inter.s1.i.loop_min = 0
       let denominator_inter.s1.i.loop_extent = 1
       let t4 = denominator.s1.rv$x
       let t3 = denominator.s1.rv$x
       let denominator_inter.s0.i.loop_min.orig = 0
       let denominator_inter.s0.i = 0
       denominator_inter(0, denominator.s1.rv$x) = 0
       denominator_inter(0, denominator.s1.rv$x) = denominator.s1.rv$x
      }
      consume denominator_inter {
       denominator(0, numerator.s1.rv$x) = denominator(0, numerator.s1.rv$x) + denominator_inter(0, numerator.s1.rv$x)
      }
     }
    }
   }
  }
  consume numerator {
   consume denominator {
    produce next {
     let next.s0.si.loop_max = (next.extent.0 + next.min.0) + -1
     let next.s0.si.loop_min = next.min.0
     let next.s0.si.loop_extent = next.extent.0
     let next.s0.si.loop_min.orig = next.min.0
     for (next.s0.si, next.min.0, next.extent.0) {
      next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
     }
    }
   }
  }
 }
}

Adding checks for images
Injecting constraints for next.0
Lowering after injecting image checks:
let next.s0.si.max = (next.extent.0 + next.min.0) + -1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = 9
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = (next.extent.0 + next.min.0) + -1
let numerator.s1.si.min = next.min.0
let numerator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let numerator.s0.si.min = min(next.min.0, 0)
let denominator.s1.rv$x.max = 9
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = (next.extent.0 + next.min.0) + -1
let denominator.s1.si.min = next.min.0
let denominator.s1.i.max = 0
let denominator.s1.i.min = 0
let denominator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let denominator.s0.si.min = min(next.min.0, 0)
let denominator.s0.i.max = 0
let denominator.s0.i.min = 0
let denominator_inter.s1.vis.max = 9
let denominator_inter.s1.vis.min = 0
let denominator_inter.s1.i.max = 0
let denominator_inter.s1.i.min = 0
let denominator_inter.s0.vis.max = 9
let denominator_inter.s0.vis.min = 0
let denominator_inter.s0.i.max = 0
let denominator_inter.s0.i.min = 0
let next.extent.0.required = (((next.extent.0 + next.min.0) + -1) + 1) - next.min.0
let next.min.0.required = next.min.0
let next.stride.0.required = 1
let next.stride.0.constrained = 1
let next.stride.0.proposed = 1
let next.min.0.proposed = next.min.0.required
let next.extent.0.proposed = next.extent.0.required
assert(!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer) || ((next.min.0.proposed <= next.min.0.required) && (((next.min.0.proposed + next.extent.0.proposed) - 1) >= ((next.min.0.required + next.extent.0.required) - 1))), halide_error_constraints_make_required_region_smaller("Output buffer next", 0, next.min.0.proposed, (next.min.0.proposed + next.extent.0.proposed) - 1, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1))
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0.proposed, next.extent.0.proposed, next.stride.0.proposed, 0), (uint64)0)
}
if (!((uint1)0 || (uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer))) {
 assert((uint32)next.type == (uint32)73728, halide_error_bad_type("Output buffer next", (uint32)next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert((next.min.0 <= next.min.0.required) && (((next.min.0 + next.extent.0) - 1) >= ((next.min.0.required + next.extent.0.required) - 1)), halide_error_access_out_of_bounds("Output buffer next", 0, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1, next.min.0, (next.min.0 + next.extent.0) - 1))
 assert(next.extent.0 >= 0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == next.stride.0.constrained, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", next.stride.0.constrained))
 let next.total_extent.0 = int64(next.extent.0)
 assert((uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", (uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)), (uint64)2147483647))
 assert(!(uint1)next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert((void *)next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
 let numerator.si.min_realized = min(next.min.0, 0)
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
  let denominator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
  let denominator.si.min_realized = min(next.min.0, 0)
  let denominator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
  let denominator.i.max_realized = 0
  let denominator.i.min_realized = 0
  let denominator.i.extent_realized = 1
  realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
   produce numerator {
    produce denominator {
     let denominator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
     let denominator.s0.si.loop_min = min(next.min.0, 0)
     let denominator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
     let denominator.s0.i.loop_max = 0
     let denominator.s0.i.loop_min = 0
     let denominator.s0.i.loop_extent = 1
     let numerator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
     let numerator.s0.si.loop_min = min(next.min.0, 0)
     let numerator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
     let numerator.s1.rv$x.loop_extent = 10
     let numerator.s1.rv$x.loop_max = 9
     let numerator.s1.rv$x.loop_min = 0
     let numerator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
     let numerator.s1.si.loop_min = next.min.0
     let numerator.s1.si.loop_extent = next.extent.0
     let denominator.s1.rv$x.loop_extent = 10
     let denominator.s1.rv$x.loop_max = 9
     let denominator.s1.rv$x.loop_min = 0
     let denominator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
     let denominator.s1.si.loop_min = next.min.0
     let denominator.s1.si.loop_extent = next.extent.0
     let denominator.s1.i.loop_max = 0
     let denominator.s1.i.loop_min = 0
     let denominator.s1.i.loop_extent = 1
     let denominator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (denominator.s0.si, min(next.min.0, 0), denominator.s0.si.loop_extent) {
      let denominator.s0.i.loop_min.orig = 0
      let denominator.s0.i = 0
      denominator(0, denominator.s0.si) = 0
     }
     let numerator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (numerator.s0.si, min(next.min.0, 0), numerator.s0.si.loop_extent) {
      numerator(numerator.s0.si) = 0
     }
     let numerator.s1.rv$x.loop_min.orig = 0
     for (numerator.s1.rv$x, 0, 10) {
      let numerator.s1.rv$x.max_1 = numerator.s1.rv$x
      let numerator.s1.rv$x.min_1 = numerator.s1.rv$x
      let denominator.s1.rv$x.max_1 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_1 = denominator.s1.rv$x
      let numerator.s1.si.min_1 = numerator.s1.rv$x
      let numerator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.si.min_1 = numerator.s1.rv$x
      let denominator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.i.min_1 = 0
      let denominator.s1.i.max_1 = 0
      let denominator_inter.s1.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_1 = 0
      let denominator_inter.s1.i.min_1 = 0
      let denominator_inter.s0.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_1 = 0
      let denominator_inter.s0.i.min_1 = 0
      numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_extent = 1
      let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min.orig = numerator.s1.rv$x
      let denominator.s1.fused.rv$x = numerator.s1.rv$x
      let denominator.s1.i.loop_min.orig = 0
      let denominator.s1.i = 0
      let denominator.s1.rv$x.max_2 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_2 = denominator.s1.rv$x
      let denominator.s1.si.min_2 = numerator.s1.rv$x
      let denominator.s1.si.max_2 = numerator.s1.rv$x
      let denominator.s1.i.min_2 = 0
      let denominator.s1.i.max_2 = 0
      let denominator_inter.s1.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_2 = 0
      let denominator_inter.s1.i.min_2 = 0
      let denominator_inter.s0.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_2 = 0
      let denominator_inter.s0.i.min_2 = 0
      let denominator_inter.vis.max_realized = max(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.extent_realized = (max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)) + 1
      let denominator_inter.i.max_realized = 0
      let denominator_inter.i.min_realized = 0
      let denominator_inter.i.extent_realized = 1
      realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
       produce denominator_inter {
        let denominator_inter.s0.vis.loop_max = denominator.s1.rv$x
        let denominator_inter.s0.vis.loop_min = denominator.s1.rv$x
        let denominator_inter.s0.vis.loop_extent = 1
        let denominator_inter.s0.i.loop_max = 0
        let denominator_inter.s0.i.loop_min = 0
        let denominator_inter.s0.i.loop_extent = 1
        let denominator_inter.s1.vis.loop_max = denominator.s1.rv$x
        let denominator_inter.s1.vis.loop_min = denominator.s1.rv$x
        let denominator_inter.s1.vis.loop_extent = 1
        let denominator_inter.s1.i.loop_max = 0
        let denominator_inter.s1.i.loop_min = 0
        let denominator_inter.s1.i.loop_extent = 1
        let t4 = denominator.s1.rv$x
        let t3 = denominator.s1.rv$x
        let denominator_inter.s0.i.loop_min.orig = 0
        let denominator_inter.s0.i = 0
        denominator_inter(0, denominator.s1.rv$x) = 0
        denominator_inter(0, denominator.s1.rv$x) = denominator.s1.rv$x
       }
       consume denominator_inter {
        denominator(0, numerator.s1.rv$x) = denominator(0, numerator.s1.rv$x) + denominator_inter(0, numerator.s1.rv$x)
       }
      }
     }
    }
   }
   consume numerator {
    consume denominator {
     produce next {
      let next.s0.si.loop_max = (next.extent.0 + next.min.0) + -1
      let next.s0.si.loop_min = next.min.0
      let next.s0.si.loop_extent = next.extent.0
      let next.s0.si.loop_min.orig = next.min.0
      for (next.s0.si, next.min.0, next.extent.0) {
       next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
      }
     }
    }
   }
  }
 }
}

Removing code that depends on undef values...
Lowering after removing code that depends on undef values: (unchanged)

Performing storage folding optimization...
Lowering after storage folding:
let next.s0.si.max = (next.extent.0 + next.min.0) + -1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = 9
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = (next.extent.0 + next.min.0) + -1
let numerator.s1.si.min = next.min.0
let numerator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let numerator.s0.si.min = min(next.min.0, 0)
let denominator.s1.rv$x.max = 9
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = (next.extent.0 + next.min.0) + -1
let denominator.s1.si.min = next.min.0
let denominator.s1.i.max = 0
let denominator.s1.i.min = 0
let denominator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let denominator.s0.si.min = min(next.min.0, 0)
let denominator.s0.i.max = 0
let denominator.s0.i.min = 0
let denominator_inter.s1.vis.max = 9
let denominator_inter.s1.vis.min = 0
let denominator_inter.s1.i.max = 0
let denominator_inter.s1.i.min = 0
let denominator_inter.s0.vis.max = 9
let denominator_inter.s0.vis.min = 0
let denominator_inter.s0.i.max = 0
let denominator_inter.s0.i.min = 0
let next.extent.0.required = (((next.extent.0 + next.min.0) + -1) + 1) - next.min.0
let next.min.0.required = next.min.0
let next.stride.0.required = 1
let next.stride.0.constrained = 1
let next.stride.0.proposed = 1
let next.min.0.proposed = next.min.0.required
let next.extent.0.proposed = next.extent.0.required
assert(!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer) || ((next.min.0.proposed <= next.min.0.required) && (((next.min.0.proposed + next.extent.0.proposed) - 1) >= ((next.min.0.required + next.extent.0.required) - 1))), halide_error_constraints_make_required_region_smaller("Output buffer next", 0, next.min.0.proposed, (next.min.0.proposed + next.extent.0.proposed) - 1, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1))
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0.proposed, next.extent.0.proposed, next.stride.0.proposed, 0), (uint64)0)
}
if (!((uint1)0 || (uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer))) {
 assert((uint32)next.type == (uint32)73728, halide_error_bad_type("Output buffer next", (uint32)next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert((next.min.0 <= next.min.0.required) && (((next.min.0 + next.extent.0) - 1) >= ((next.min.0.required + next.extent.0.required) - 1)), halide_error_access_out_of_bounds("Output buffer next", 0, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1, next.min.0, (next.min.0 + next.extent.0) - 1))
 assert(next.extent.0 >= 0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == next.stride.0.constrained, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", next.stride.0.constrained))
 let next.total_extent.0 = int64(next.extent.0)
 assert((uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", (uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)), (uint64)2147483647))
 assert(!(uint1)next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert((void *)next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
 let numerator.si.min_realized = min(next.min.0, 0)
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
  let denominator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
  let denominator.si.min_realized = min(next.min.0, 0)
  let denominator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
  let denominator.i.max_realized = 0
  let denominator.i.min_realized = 0
  let denominator.i.extent_realized = 1
  realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
   produce numerator {
    produce denominator {
     let denominator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
     let denominator.s0.si.loop_min = min(next.min.0, 0)
     let denominator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
     let denominator.s0.i.loop_max = 0
     let denominator.s0.i.loop_min = 0
     let denominator.s0.i.loop_extent = 1
     let numerator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
     let numerator.s0.si.loop_min = min(next.min.0, 0)
     let numerator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
     let numerator.s1.rv$x.loop_extent = 10
     let numerator.s1.rv$x.loop_max = 9
     let numerator.s1.rv$x.loop_min = 0
     let numerator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
     let numerator.s1.si.loop_min = next.min.0
     let numerator.s1.si.loop_extent = next.extent.0
     let denominator.s1.rv$x.loop_extent = 10
     let denominator.s1.rv$x.loop_max = 9
     let denominator.s1.rv$x.loop_min = 0
     let denominator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
     let denominator.s1.si.loop_min = next.min.0
     let denominator.s1.si.loop_extent = next.extent.0
     let denominator.s1.i.loop_max = 0
     let denominator.s1.i.loop_min = 0
     let denominator.s1.i.loop_extent = 1
     let denominator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (denominator.s0.si, min(next.min.0, 0), denominator.s0.si.loop_extent) {
      let denominator.s0.i.loop_min.orig = 0
      let denominator.s0.i = 0
      denominator(0, denominator.s0.si) = 0
     }
     let numerator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (numerator.s0.si, min(next.min.0, 0), numerator.s0.si.loop_extent) {
      numerator(numerator.s0.si) = 0
     }
     let numerator.s1.rv$x.loop_min.orig = 0
     for (numerator.s1.rv$x, 0, 10) {
      let numerator.s1.rv$x.max_1 = numerator.s1.rv$x
      let numerator.s1.rv$x.min_1 = numerator.s1.rv$x
      let denominator.s1.rv$x.max_1 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_1 = denominator.s1.rv$x
      let numerator.s1.si.min_1 = numerator.s1.rv$x
      let numerator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.si.min_1 = numerator.s1.rv$x
      let denominator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.i.min_1 = 0
      let denominator.s1.i.max_1 = 0
      let denominator_inter.s1.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_1 = 0
      let denominator_inter.s1.i.min_1 = 0
      let denominator_inter.s0.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_1 = 0
      let denominator_inter.s0.i.min_1 = 0
      numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_extent = 1
      let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min.orig = numerator.s1.rv$x
      let denominator.s1.fused.rv$x = numerator.s1.rv$x
      let denominator.s1.i.loop_min.orig = 0
      let denominator.s1.i = 0
      let denominator.s1.rv$x.max_2 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_2 = denominator.s1.rv$x
      let denominator.s1.si.min_2 = numerator.s1.rv$x
      let denominator.s1.si.max_2 = numerator.s1.rv$x
      let denominator.s1.i.min_2 = 0
      let denominator.s1.i.max_2 = 0
      let denominator_inter.s1.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_2 = 0
      let denominator_inter.s1.i.min_2 = 0
      let denominator_inter.s0.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_2 = 0
      let denominator_inter.s0.i.min_2 = 0
      let denominator_inter.vis.max_realized = max(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.extent_realized = (max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)) + 1
      let denominator_inter.i.max_realized = 0
      let denominator_inter.i.min_realized = 0
      let denominator_inter.i.extent_realized = 1
      realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
       produce denominator_inter {
        let denominator_inter.s0.vis.loop_max = denominator.s1.rv$x
        let denominator_inter.s0.vis.loop_min = denominator.s1.rv$x
        let denominator_inter.s0.vis.loop_extent = 1
        let denominator_inter.s0.i.loop_max = 0
        let denominator_inter.s0.i.loop_min = 0
        let denominator_inter.s0.i.loop_extent = 1
        let denominator_inter.s1.vis.loop_max = denominator.s1.rv$x
        let denominator_inter.s1.vis.loop_min = denominator.s1.rv$x
        let denominator_inter.s1.vis.loop_extent = 1
        let denominator_inter.s1.i.loop_max = 0
        let denominator_inter.s1.i.loop_min = 0
        let denominator_inter.s1.i.loop_extent = 1
        let t4 = denominator.s1.rv$x
        let t3 = denominator.s1.rv$x
        let denominator_inter.s0.i.loop_min.orig = 0
        let denominator_inter.s0.i = 0
        denominator_inter(0, denominator.s1.rv$x) = 0
        denominator_inter(0, denominator.s1.rv$x) = denominator.s1.rv$x
       }
       consume denominator_inter {
        denominator(0, numerator.s1.rv$x) = denominator(0, numerator.s1.rv$x) + denominator_inter(0, numerator.s1.rv$x)
       }
      }
     }
    }
   }
   consume numerator {
    consume denominator {
     produce next {
      let next.s0.si.loop_max = (next.extent.0 + next.min.0) + -1
      let next.s0.si.loop_min = next.min.0
      let next.s0.si.loop_extent = next.extent.0
      let next.s0.si.loop_min.orig = next.min.0
      for (next.s0.si, next.min.0, next.extent.0) {
       next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
      }
     }
    }
   }
  }
 }
}

Injecting debug_to_file calls...
Lowering after injecting debug_to_file calls:
let next.s0.si.max = (next.extent.0 + next.min.0) + -1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = 9
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = (next.extent.0 + next.min.0) + -1
let numerator.s1.si.min = next.min.0
let numerator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let numerator.s0.si.min = min(next.min.0, 0)
let denominator.s1.rv$x.max = 9
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = (next.extent.0 + next.min.0) + -1
let denominator.s1.si.min = next.min.0
let denominator.s1.i.max = 0
let denominator.s1.i.min = 0
let denominator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let denominator.s0.si.min = min(next.min.0, 0)
let denominator.s0.i.max = 0
let denominator.s0.i.min = 0
let denominator_inter.s1.vis.max = 9
let denominator_inter.s1.vis.min = 0
let denominator_inter.s1.i.max = 0
let denominator_inter.s1.i.min = 0
let denominator_inter.s0.vis.max = 9
let denominator_inter.s0.vis.min = 0
let denominator_inter.s0.i.max = 0
let denominator_inter.s0.i.min = 0
let next.extent.0.required = (((next.extent.0 + next.min.0) + -1) + 1) - next.min.0
let next.min.0.required = next.min.0
let next.stride.0.required = 1
let next.stride.0.constrained = 1
let next.stride.0.proposed = 1
let next.min.0.proposed = next.min.0.required
let next.extent.0.proposed = next.extent.0.required
assert(!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer) || ((next.min.0.proposed <= next.min.0.required) && (((next.min.0.proposed + next.extent.0.proposed) - 1) >= ((next.min.0.required + next.extent.0.required) - 1))), halide_error_constraints_make_required_region_smaller("Output buffer next", 0, next.min.0.proposed, (next.min.0.proposed + next.extent.0.proposed) - 1, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1))
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0.proposed, next.extent.0.proposed, next.stride.0.proposed, 0), (uint64)0)
}
if (!((uint1)0 || (uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer))) {
 assert((uint32)next.type == (uint32)73728, halide_error_bad_type("Output buffer next", (uint32)next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert((next.min.0 <= next.min.0.required) && (((next.min.0 + next.extent.0) - 1) >= ((next.min.0.required + next.extent.0.required) - 1)), halide_error_access_out_of_bounds("Output buffer next", 0, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1, next.min.0, (next.min.0 + next.extent.0) - 1))
 assert(next.extent.0 >= 0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == next.stride.0.constrained, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", next.stride.0.constrained))
 let next.total_extent.0 = int64(next.extent.0)
 assert((uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", (uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)), (uint64)2147483647))
 assert(!(uint1)next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert((void *)next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
 let numerator.si.min_realized = min(next.min.0, 0)
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
  let denominator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
  let denominator.si.min_realized = min(next.min.0, 0)
  let denominator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
  let denominator.i.max_realized = 0
  let denominator.i.min_realized = 0
  let denominator.i.extent_realized = 1
  realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
   produce numerator {
    produce denominator {
     let denominator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
     let denominator.s0.si.loop_min = min(next.min.0, 0)
     let denominator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
     let denominator.s0.i.loop_max = 0
     let denominator.s0.i.loop_min = 0
     let denominator.s0.i.loop_extent = 1
     let numerator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
     let numerator.s0.si.loop_min = min(next.min.0, 0)
     let numerator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
     let numerator.s1.rv$x.loop_extent = 10
     let numerator.s1.rv$x.loop_max = 9
     let numerator.s1.rv$x.loop_min = 0
     let numerator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
     let numerator.s1.si.loop_min = next.min.0
     let numerator.s1.si.loop_extent = next.extent.0
     let denominator.s1.rv$x.loop_extent = 10
     let denominator.s1.rv$x.loop_max = 9
     let denominator.s1.rv$x.loop_min = 0
     let denominator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
     let denominator.s1.si.loop_min = next.min.0
     let denominator.s1.si.loop_extent = next.extent.0
     let denominator.s1.i.loop_max = 0
     let denominator.s1.i.loop_min = 0
     let denominator.s1.i.loop_extent = 1
     let denominator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (denominator.s0.si, min(next.min.0, 0), denominator.s0.si.loop_extent) {
      let denominator.s0.i.loop_min.orig = 0
      let denominator.s0.i = 0
      denominator(0, denominator.s0.si) = 0
     }
     let numerator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (numerator.s0.si, min(next.min.0, 0), numerator.s0.si.loop_extent) {
      numerator(numerator.s0.si) = 0
     }
     let numerator.s1.rv$x.loop_min.orig = 0
     for (numerator.s1.rv$x, 0, 10) {
      let numerator.s1.rv$x.max_1 = numerator.s1.rv$x
      let numerator.s1.rv$x.min_1 = numerator.s1.rv$x
      let denominator.s1.rv$x.max_1 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_1 = denominator.s1.rv$x
      let numerator.s1.si.min_1 = numerator.s1.rv$x
      let numerator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.si.min_1 = numerator.s1.rv$x
      let denominator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.i.min_1 = 0
      let denominator.s1.i.max_1 = 0
      let denominator_inter.s1.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_1 = 0
      let denominator_inter.s1.i.min_1 = 0
      let denominator_inter.s0.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_1 = 0
      let denominator_inter.s0.i.min_1 = 0
      numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_extent = 1
      let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min.orig = numerator.s1.rv$x
      let denominator.s1.fused.rv$x = numerator.s1.rv$x
      let denominator.s1.i.loop_min.orig = 0
      let denominator.s1.i = 0
      let denominator.s1.rv$x.max_2 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_2 = denominator.s1.rv$x
      let denominator.s1.si.min_2 = numerator.s1.rv$x
      let denominator.s1.si.max_2 = numerator.s1.rv$x
      let denominator.s1.i.min_2 = 0
      let denominator.s1.i.max_2 = 0
      let denominator_inter.s1.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_2 = 0
      let denominator_inter.s1.i.min_2 = 0
      let denominator_inter.s0.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_2 = 0
      let denominator_inter.s0.i.min_2 = 0
      let denominator_inter.vis.max_realized = max(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.extent_realized = (max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)) + 1
      let denominator_inter.i.max_realized = 0
      let denominator_inter.i.min_realized = 0
      let denominator_inter.i.extent_realized = 1
      realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
       produce denominator_inter {
        let denominator_inter.s0.vis.loop_max = denominator.s1.rv$x
        let denominator_inter.s0.vis.loop_min = denominator.s1.rv$x
        let denominator_inter.s0.vis.loop_extent = 1
        let denominator_inter.s0.i.loop_max = 0
        let denominator_inter.s0.i.loop_min = 0
        let denominator_inter.s0.i.loop_extent = 1
        let denominator_inter.s1.vis.loop_max = denominator.s1.rv$x
        let denominator_inter.s1.vis.loop_min = denominator.s1.rv$x
        let denominator_inter.s1.vis.loop_extent = 1
        let denominator_inter.s1.i.loop_max = 0
        let denominator_inter.s1.i.loop_min = 0
        let denominator_inter.s1.i.loop_extent = 1
        let t4 = denominator.s1.rv$x
        let t3 = denominator.s1.rv$x
        let denominator_inter.s0.i.loop_min.orig = 0
        let denominator_inter.s0.i = 0
        denominator_inter(0, denominator.s1.rv$x) = 0
        denominator_inter(0, denominator.s1.rv$x) = denominator.s1.rv$x
       }
       consume denominator_inter {
        denominator(0, numerator.s1.rv$x) = denominator(0, numerator.s1.rv$x) + denominator_inter(0, numerator.s1.rv$x)
       }
      }
     }
    }
   }
   consume numerator {
    consume denominator {
     produce next {
      let next.s0.si.loop_max = (next.extent.0 + next.min.0) + -1
      let next.s0.si.loop_min = next.min.0
      let next.s0.si.loop_extent = next.extent.0
      let next.s0.si.loop_min.orig = next.min.0
      for (next.s0.si, next.min.0, next.extent.0) {
       next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
      }
     }
    }
   }
  }
 }
}

Injecting prefetches...
Lowering after injecting prefetches: (unchanged)

Discarding safe promises...
Lowering after discarding safe promises: (unchanged)

Dynamically skipping stages...
skip_stages checking numerator
skip_stages can skip numerator
skip_stages checking denominator
skip_stages can skip denominator
skip_stages checking denominator_inter
skip_stages can skip denominator_inter
Lowering after dynamically skipping stages:
let next.s0.si.max = (next.extent.0 + next.min.0) + -1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = 9
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = (next.extent.0 + next.min.0) + -1
let numerator.s1.si.min = next.min.0
let numerator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let numerator.s0.si.min = min(next.min.0, 0)
let denominator.s1.rv$x.max = 9
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = (next.extent.0 + next.min.0) + -1
let denominator.s1.si.min = next.min.0
let denominator.s1.i.max = 0
let denominator.s1.i.min = 0
let denominator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let denominator.s0.si.min = min(next.min.0, 0)
let denominator.s0.i.max = 0
let denominator.s0.i.min = 0
let denominator_inter.s1.vis.max = 9
let denominator_inter.s1.vis.min = 0
let denominator_inter.s1.i.max = 0
let denominator_inter.s1.i.min = 0
let denominator_inter.s0.vis.max = 9
let denominator_inter.s0.vis.min = 0
let denominator_inter.s0.i.max = 0
let denominator_inter.s0.i.min = 0
let next.extent.0.required = (((next.extent.0 + next.min.0) + -1) + 1) - next.min.0
let next.min.0.required = next.min.0
let next.stride.0.required = 1
let next.stride.0.constrained = 1
let next.stride.0.proposed = 1
let next.min.0.proposed = next.min.0.required
let next.extent.0.proposed = next.extent.0.required
assert(!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer) || ((next.min.0.proposed <= next.min.0.required) && (((next.min.0.proposed + next.extent.0.proposed) - 1) >= ((next.min.0.required + next.extent.0.required) - 1))), halide_error_constraints_make_required_region_smaller("Output buffer next", 0, next.min.0.proposed, (next.min.0.proposed + next.extent.0.proposed) - 1, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1))
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0.proposed, next.extent.0.proposed, next.stride.0.proposed, 0), (uint64)0)
}
if (!((uint1)0 || (uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer))) {
 assert((uint32)next.type == (uint32)73728, halide_error_bad_type("Output buffer next", (uint32)next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert((next.min.0 <= next.min.0.required) && (((next.min.0 + next.extent.0) - 1) >= ((next.min.0.required + next.extent.0.required) - 1)), halide_error_access_out_of_bounds("Output buffer next", 0, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1, next.min.0, (next.min.0 + next.extent.0) - 1))
 assert(next.extent.0 >= 0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == next.stride.0.constrained, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", next.stride.0.constrained))
 let next.total_extent.0 = int64(next.extent.0)
 assert((uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", (uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)), (uint64)2147483647))
 assert(!(uint1)next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert((void *)next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
 let numerator.si.min_realized = min(next.min.0, 0)
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
  let denominator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
  let denominator.si.min_realized = min(next.min.0, 0)
  let denominator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
  let denominator.i.max_realized = 0
  let denominator.i.min_realized = 0
  let denominator.i.extent_realized = 1
  realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
   produce numerator {
    produce denominator {
     let denominator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
     let denominator.s0.si.loop_min = min(next.min.0, 0)
     let denominator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
     let denominator.s0.i.loop_max = 0
     let denominator.s0.i.loop_min = 0
     let denominator.s0.i.loop_extent = 1
     let numerator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
     let numerator.s0.si.loop_min = min(next.min.0, 0)
     let numerator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
     let numerator.s1.rv$x.loop_extent = 10
     let numerator.s1.rv$x.loop_max = 9
     let numerator.s1.rv$x.loop_min = 0
     let numerator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
     let numerator.s1.si.loop_min = next.min.0
     let numerator.s1.si.loop_extent = next.extent.0
     let denominator.s1.rv$x.loop_extent = 10
     let denominator.s1.rv$x.loop_max = 9
     let denominator.s1.rv$x.loop_min = 0
     let denominator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
     let denominator.s1.si.loop_min = next.min.0
     let denominator.s1.si.loop_extent = next.extent.0
     let denominator.s1.i.loop_max = 0
     let denominator.s1.i.loop_min = 0
     let denominator.s1.i.loop_extent = 1
     let denominator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (denominator.s0.si, min(next.min.0, 0), denominator.s0.si.loop_extent) {
      let denominator.s0.i.loop_min.orig = 0
      let denominator.s0.i = 0
      denominator(0, denominator.s0.si) = 0
     }
     let numerator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (numerator.s0.si, min(next.min.0, 0), numerator.s0.si.loop_extent) {
      numerator(numerator.s0.si) = 0
     }
     let numerator.s1.rv$x.loop_min.orig = 0
     for (numerator.s1.rv$x, 0, 10) {
      let numerator.s1.rv$x.max_1 = numerator.s1.rv$x
      let numerator.s1.rv$x.min_1 = numerator.s1.rv$x
      let denominator.s1.rv$x.max_1 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_1 = denominator.s1.rv$x
      let numerator.s1.si.min_1 = numerator.s1.rv$x
      let numerator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.si.min_1 = numerator.s1.rv$x
      let denominator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.i.min_1 = 0
      let denominator.s1.i.max_1 = 0
      let denominator_inter.s1.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_1 = 0
      let denominator_inter.s1.i.min_1 = 0
      let denominator_inter.s0.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_1 = 0
      let denominator_inter.s0.i.min_1 = 0
      numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_extent = 1
      let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min.orig = numerator.s1.rv$x
      let denominator.s1.fused.rv$x = numerator.s1.rv$x
      let denominator.s1.i.loop_min.orig = 0
      let denominator.s1.i = 0
      let denominator.s1.rv$x.max_2 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_2 = denominator.s1.rv$x
      let denominator.s1.si.min_2 = numerator.s1.rv$x
      let denominator.s1.si.max_2 = numerator.s1.rv$x
      let denominator.s1.i.min_2 = 0
      let denominator.s1.i.max_2 = 0
      let denominator_inter.s1.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_2 = 0
      let denominator_inter.s1.i.min_2 = 0
      let denominator_inter.s0.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_2 = 0
      let denominator_inter.s0.i.min_2 = 0
      let denominator_inter.vis.max_realized = max(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.extent_realized = (max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)) + 1
      let denominator_inter.i.max_realized = 0
      let denominator_inter.i.min_realized = 0
      let denominator_inter.i.extent_realized = 1
      realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
       produce denominator_inter {
        let denominator_inter.s0.vis.loop_max = denominator.s1.rv$x
        let denominator_inter.s0.vis.loop_min = denominator.s1.rv$x
        let denominator_inter.s0.vis.loop_extent = 1
        let denominator_inter.s0.i.loop_max = 0
        let denominator_inter.s0.i.loop_min = 0
        let denominator_inter.s0.i.loop_extent = 1
        let denominator_inter.s1.vis.loop_max = denominator.s1.rv$x
        let denominator_inter.s1.vis.loop_min = denominator.s1.rv$x
        let denominator_inter.s1.vis.loop_extent = 1
        let denominator_inter.s1.i.loop_max = 0
        let denominator_inter.s1.i.loop_min = 0
        let denominator_inter.s1.i.loop_extent = 1
        let t4 = denominator.s1.rv$x
        let t3 = denominator.s1.rv$x
        let denominator_inter.s0.i.loop_min.orig = 0
        let denominator_inter.s0.i = 0
        denominator_inter(0, denominator.s1.rv$x) = 0
        denominator_inter(0, denominator.s1.rv$x) = denominator.s1.rv$x
       }
       consume denominator_inter {
        denominator(0, numerator.s1.rv$x) = denominator(0, numerator.s1.rv$x) + denominator_inter(0, numerator.s1.rv$x)
       }
      }
     }
    }
   }
   consume numerator {
    consume denominator {
     produce next {
      let next.s0.si.loop_max = (next.extent.0 + next.min.0) + -1
      let next.s0.si.loop_min = next.min.0
      let next.s0.si.loop_extent = next.extent.0
      let next.s0.si.loop_min.orig = next.min.0
      for (next.s0.si, next.min.0, next.extent.0) {
       next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
      }
     }
    }
   }
  }
 }
}

Forking asynchronous producers...
Lowering after forking asynchronous producers:
let next.s0.si.max = (next.extent.0 + next.min.0) + -1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = 9
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = (next.extent.0 + next.min.0) + -1
let numerator.s1.si.min = next.min.0
let numerator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let numerator.s0.si.min = min(next.min.0, 0)
let denominator.s1.rv$x.max = 9
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = (next.extent.0 + next.min.0) + -1
let denominator.s1.si.min = next.min.0
let denominator.s1.i.max = 0
let denominator.s1.i.min = 0
let denominator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let denominator.s0.si.min = min(next.min.0, 0)
let denominator.s0.i.max = 0
let denominator.s0.i.min = 0
let denominator_inter.s1.vis.max = 9
let denominator_inter.s1.vis.min = 0
let denominator_inter.s1.i.max = 0
let denominator_inter.s1.i.min = 0
let denominator_inter.s0.vis.max = 9
let denominator_inter.s0.vis.min = 0
let denominator_inter.s0.i.max = 0
let denominator_inter.s0.i.min = 0
let next.extent.0.required = (((next.extent.0 + next.min.0) + -1) + 1) - next.min.0
let next.min.0.required = next.min.0
let next.stride.0.required = 1
let next.stride.0.constrained = 1
let next.stride.0.proposed = 1
let next.min.0.proposed = next.min.0.required
let next.extent.0.proposed = next.extent.0.required
assert(!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer) || ((next.min.0.proposed <= next.min.0.required) && (((next.min.0.proposed + next.extent.0.proposed) - 1) >= ((next.min.0.required + next.extent.0.required) - 1))), halide_error_constraints_make_required_region_smaller("Output buffer next", 0, next.min.0.proposed, (next.min.0.proposed + next.extent.0.proposed) - 1, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1))
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0.proposed, next.extent.0.proposed, next.stride.0.proposed, 0), (uint64)0)
}
if (!((uint1)0 || (uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer))) {
 assert((uint32)next.type == (uint32)73728, halide_error_bad_type("Output buffer next", (uint32)next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert((next.min.0 <= next.min.0.required) && (((next.min.0 + next.extent.0) - 1) >= ((next.min.0.required + next.extent.0.required) - 1)), halide_error_access_out_of_bounds("Output buffer next", 0, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1, next.min.0, (next.min.0 + next.extent.0) - 1))
 assert(next.extent.0 >= 0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == next.stride.0.constrained, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", next.stride.0.constrained))
 let next.total_extent.0 = int64(next.extent.0)
 assert((uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", (uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)), (uint64)2147483647))
 assert(!(uint1)next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert((void *)next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
 let numerator.si.min_realized = min(next.min.0, 0)
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
  let denominator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
  let denominator.si.min_realized = min(next.min.0, 0)
  let denominator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
  let denominator.i.max_realized = 0
  let denominator.i.min_realized = 0
  let denominator.i.extent_realized = 1
  realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
   let denominator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
   let denominator.s0.si.loop_min = min(next.min.0, 0)
   let denominator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
   let denominator.s0.i.loop_max = 0
   let denominator.s0.i.loop_min = 0
   let denominator.s0.i.loop_extent = 1
   let numerator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
   let numerator.s0.si.loop_min = min(next.min.0, 0)
   let numerator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
   let numerator.s1.rv$x.loop_extent = 10
   let numerator.s1.rv$x.loop_max = 9
   let numerator.s1.rv$x.loop_min = 0
   let numerator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
   let numerator.s1.si.loop_min = next.min.0
   let numerator.s1.si.loop_extent = next.extent.0
   let denominator.s1.rv$x.loop_extent = 10
   let denominator.s1.rv$x.loop_max = 9
   let denominator.s1.rv$x.loop_min = 0
   let denominator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
   let denominator.s1.si.loop_min = next.min.0
   let denominator.s1.si.loop_extent = next.extent.0
   let denominator.s1.i.loop_max = 0
   let denominator.s1.i.loop_min = 0
   let denominator.s1.i.loop_extent = 1
   produce denominator {
    produce numerator {
     let denominator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (denominator.s0.si, min(next.min.0, 0), denominator.s0.si.loop_extent) {
      let denominator.s0.i.loop_min.orig = 0
      let denominator.s0.i = 0
      denominator(0, denominator.s0.si) = 0
     }
     let numerator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (numerator.s0.si, min(next.min.0, 0), numerator.s0.si.loop_extent) {
      numerator(numerator.s0.si) = 0
     }
     let numerator.s1.rv$x.loop_min.orig = 0
     for (numerator.s1.rv$x, 0, 10) {
      let numerator.s1.rv$x.max_1 = numerator.s1.rv$x
      let numerator.s1.rv$x.min_1 = numerator.s1.rv$x
      let denominator.s1.rv$x.max_1 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_1 = denominator.s1.rv$x
      let numerator.s1.si.min_1 = numerator.s1.rv$x
      let numerator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.si.min_1 = numerator.s1.rv$x
      let denominator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.i.min_1 = 0
      let denominator.s1.i.max_1 = 0
      let denominator_inter.s1.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_1 = 0
      let denominator_inter.s1.i.min_1 = 0
      let denominator_inter.s0.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_1 = 0
      let denominator_inter.s0.i.min_1 = 0
      numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_extent = 1
      let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min.orig = numerator.s1.rv$x
      let denominator.s1.fused.rv$x = numerator.s1.rv$x
      let denominator.s1.i.loop_min.orig = 0
      let denominator.s1.i = 0
      let denominator.s1.rv$x.max_2 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_2 = denominator.s1.rv$x
      let denominator.s1.si.min_2 = numerator.s1.rv$x
      let denominator.s1.si.max_2 = numerator.s1.rv$x
      let denominator.s1.i.min_2 = 0
      let denominator.s1.i.max_2 = 0
      let denominator_inter.s1.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_2 = 0
      let denominator_inter.s1.i.min_2 = 0
      let denominator_inter.s0.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_2 = 0
      let denominator_inter.s0.i.min_2 = 0
      let denominator_inter.vis.max_realized = max(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.extent_realized = (max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)) + 1
      let denominator_inter.i.max_realized = 0
      let denominator_inter.i.min_realized = 0
      let denominator_inter.i.extent_realized = 1
      realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
       let denominator_inter.s0.vis.loop_max = denominator.s1.rv$x
       let denominator_inter.s0.vis.loop_min = denominator.s1.rv$x
       let denominator_inter.s0.vis.loop_extent = 1
       let denominator_inter.s0.i.loop_max = 0
       let denominator_inter.s0.i.loop_min = 0
       let denominator_inter.s0.i.loop_extent = 1
       let denominator_inter.s1.vis.loop_max = denominator.s1.rv$x
       let denominator_inter.s1.vis.loop_min = denominator.s1.rv$x
       let denominator_inter.s1.vis.loop_extent = 1
       let denominator_inter.s1.i.loop_max = 0
       let denominator_inter.s1.i.loop_min = 0
       let denominator_inter.s1.i.loop_extent = 1
       let t4 = denominator.s1.rv$x
       let t3 = denominator.s1.rv$x
       produce denominator_inter {
        let denominator_inter.s0.i.loop_min.orig = 0
        let denominator_inter.s0.i = 0
        denominator_inter(0, denominator.s1.rv$x) = 0
        denominator_inter(0, denominator.s1.rv$x) = denominator.s1.rv$x
       }
       consume denominator_inter {
        denominator(0, numerator.s1.rv$x) = denominator(0, numerator.s1.rv$x) + denominator_inter(0, numerator.s1.rv$x)
       }
      }
     }
    }
   }
   let next.s0.si.loop_max = (next.extent.0 + next.min.0) + -1
   let next.s0.si.loop_min = next.min.0
   let next.s0.si.loop_extent = next.extent.0
   let next.s0.si.loop_min.orig = next.min.0
   produce next {
    consume denominator {
     consume numerator {
      for (next.s0.si, next.min.0, next.extent.0) {
       next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
      }
     }
    }
   }
  }
 }
}

Destructuring tuple-valued realizations...
Lowering after destructuring tuple-valued realizations:
let next.s0.si.max = (next.extent.0 + next.min.0) + -1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = 9
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = (next.extent.0 + next.min.0) + -1
let numerator.s1.si.min = next.min.0
let numerator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let numerator.s0.si.min = min(next.min.0, 0)
let denominator.s1.rv$x.max = 9
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = (next.extent.0 + next.min.0) + -1
let denominator.s1.si.min = next.min.0
let denominator.s1.i.max = 0
let denominator.s1.i.min = 0
let denominator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let denominator.s0.si.min = min(next.min.0, 0)
let denominator.s0.i.max = 0
let denominator.s0.i.min = 0
let denominator_inter.s1.vis.max = 9
let denominator_inter.s1.vis.min = 0
let denominator_inter.s1.i.max = 0
let denominator_inter.s1.i.min = 0
let denominator_inter.s0.vis.max = 9
let denominator_inter.s0.vis.min = 0
let denominator_inter.s0.i.max = 0
let denominator_inter.s0.i.min = 0
let next.extent.0.required = (((next.extent.0 + next.min.0) + -1) + 1) - next.min.0
let next.min.0.required = next.min.0
let next.stride.0.required = 1
let next.stride.0.constrained = 1
let next.stride.0.proposed = 1
let next.min.0.proposed = next.min.0.required
let next.extent.0.proposed = next.extent.0.required
assert(!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer) || ((next.min.0.proposed <= next.min.0.required) && (((next.min.0.proposed + next.extent.0.proposed) - 1) >= ((next.min.0.required + next.extent.0.required) - 1))), halide_error_constraints_make_required_region_smaller("Output buffer next", 0, next.min.0.proposed, (next.min.0.proposed + next.extent.0.proposed) - 1, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1))
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0.proposed, next.extent.0.proposed, next.stride.0.proposed, 0), (uint64)0)
}
if (!((uint1)0 || (uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer))) {
 assert((uint32)next.type == (uint32)73728, halide_error_bad_type("Output buffer next", (uint32)next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert((next.min.0 <= next.min.0.required) && (((next.min.0 + next.extent.0) - 1) >= ((next.min.0.required + next.extent.0.required) - 1)), halide_error_access_out_of_bounds("Output buffer next", 0, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1, next.min.0, (next.min.0 + next.extent.0) - 1))
 assert(next.extent.0 >= 0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == next.stride.0.constrained, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", next.stride.0.constrained))
 let next.total_extent.0 = int64(next.extent.0)
 assert((uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", (uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)), (uint64)2147483647))
 assert(!(uint1)next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert((void *)next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
 let numerator.si.min_realized = min(next.min.0, 0)
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
  let denominator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
  let denominator.si.min_realized = min(next.min.0, 0)
  let denominator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
  let denominator.i.max_realized = 0
  let denominator.i.min_realized = 0
  let denominator.i.extent_realized = 1
  realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
   let denominator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
   let denominator.s0.si.loop_min = min(next.min.0, 0)
   let denominator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
   let denominator.s0.i.loop_max = 0
   let denominator.s0.i.loop_min = 0
   let denominator.s0.i.loop_extent = 1
   let numerator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
   let numerator.s0.si.loop_min = min(next.min.0, 0)
   let numerator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
   let numerator.s1.rv$x.loop_extent = 10
   let numerator.s1.rv$x.loop_max = 9
   let numerator.s1.rv$x.loop_min = 0
   let numerator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
   let numerator.s1.si.loop_min = next.min.0
   let numerator.s1.si.loop_extent = next.extent.0
   let denominator.s1.rv$x.loop_extent = 10
   let denominator.s1.rv$x.loop_max = 9
   let denominator.s1.rv$x.loop_min = 0
   let denominator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
   let denominator.s1.si.loop_min = next.min.0
   let denominator.s1.si.loop_extent = next.extent.0
   let denominator.s1.i.loop_max = 0
   let denominator.s1.i.loop_min = 0
   let denominator.s1.i.loop_extent = 1
   produce denominator {
    produce numerator {
     let denominator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (denominator.s0.si, min(next.min.0, 0), denominator.s0.si.loop_extent) {
      let denominator.s0.i.loop_min.orig = 0
      let denominator.s0.i = 0
      denominator(0, denominator.s0.si) = 0
     }
     let numerator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (numerator.s0.si, min(next.min.0, 0), numerator.s0.si.loop_extent) {
      numerator(numerator.s0.si) = 0
     }
     let numerator.s1.rv$x.loop_min.orig = 0
     for (numerator.s1.rv$x, 0, 10) {
      let numerator.s1.rv$x.max_1 = numerator.s1.rv$x
      let numerator.s1.rv$x.min_1 = numerator.s1.rv$x
      let denominator.s1.rv$x.max_1 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_1 = denominator.s1.rv$x
      let numerator.s1.si.min_1 = numerator.s1.rv$x
      let numerator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.si.min_1 = numerator.s1.rv$x
      let denominator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.i.min_1 = 0
      let denominator.s1.i.max_1 = 0
      let denominator_inter.s1.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_1 = 0
      let denominator_inter.s1.i.min_1 = 0
      let denominator_inter.s0.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_1 = 0
      let denominator_inter.s0.i.min_1 = 0
      numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_extent = 1
      let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min.orig = numerator.s1.rv$x
      let denominator.s1.fused.rv$x = numerator.s1.rv$x
      let denominator.s1.i.loop_min.orig = 0
      let denominator.s1.i = 0
      let denominator.s1.rv$x.max_2 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_2 = denominator.s1.rv$x
      let denominator.s1.si.min_2 = numerator.s1.rv$x
      let denominator.s1.si.max_2 = numerator.s1.rv$x
      let denominator.s1.i.min_2 = 0
      let denominator.s1.i.max_2 = 0
      let denominator_inter.s1.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_2 = 0
      let denominator_inter.s1.i.min_2 = 0
      let denominator_inter.s0.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_2 = 0
      let denominator_inter.s0.i.min_2 = 0
      let denominator_inter.vis.max_realized = max(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.extent_realized = (max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)) + 1
      let denominator_inter.i.max_realized = 0
      let denominator_inter.i.min_realized = 0
      let denominator_inter.i.extent_realized = 1
      realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
       let denominator_inter.s0.vis.loop_max = denominator.s1.rv$x
       let denominator_inter.s0.vis.loop_min = denominator.s1.rv$x
       let denominator_inter.s0.vis.loop_extent = 1
       let denominator_inter.s0.i.loop_max = 0
       let denominator_inter.s0.i.loop_min = 0
       let denominator_inter.s0.i.loop_extent = 1
       let denominator_inter.s1.vis.loop_max = denominator.s1.rv$x
       let denominator_inter.s1.vis.loop_min = denominator.s1.rv$x
       let denominator_inter.s1.vis.loop_extent = 1
       let denominator_inter.s1.i.loop_max = 0
       let denominator_inter.s1.i.loop_min = 0
       let denominator_inter.s1.i.loop_extent = 1
       let t4 = denominator.s1.rv$x
       let t3 = denominator.s1.rv$x
       produce denominator_inter {
        let denominator_inter.s0.i.loop_min.orig = 0
        let denominator_inter.s0.i = 0
        denominator_inter(0, denominator.s1.rv$x) = 0
        denominator_inter(0, denominator.s1.rv$x) = denominator.s1.rv$x
       }
       consume denominator_inter {
        denominator(0, numerator.s1.rv$x) = denominator(0, numerator.s1.rv$x) + denominator_inter(0, numerator.s1.rv$x)
       }
      }
     }
    }
   }
   let next.s0.si.loop_max = (next.extent.0 + next.min.0) + -1
   let next.s0.si.loop_min = next.min.0
   let next.s0.si.loop_extent = next.extent.0
   let next.s0.si.loop_min.orig = next.min.0
   produce next {
    consume denominator {
     consume numerator {
      for (next.s0.si, next.min.0, next.extent.0) {
       next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
      }
     }
    }
   }
  }
 }
}

Bounding small realizations...
Warning: expression is non-monotonic in loop variable numerator.s1.rv$x: max(max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x), 0)
Lowering after bounding small realizations:
let next.s0.si.max = (next.extent.0 + next.min.0) + -1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = 9
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = (next.extent.0 + next.min.0) + -1
let numerator.s1.si.min = next.min.0
let numerator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let numerator.s0.si.min = min(next.min.0, 0)
let denominator.s1.rv$x.max = 9
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = (next.extent.0 + next.min.0) + -1
let denominator.s1.si.min = next.min.0
let denominator.s1.i.max = 0
let denominator.s1.i.min = 0
let denominator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let denominator.s0.si.min = min(next.min.0, 0)
let denominator.s0.i.max = 0
let denominator.s0.i.min = 0
let denominator_inter.s1.vis.max = 9
let denominator_inter.s1.vis.min = 0
let denominator_inter.s1.i.max = 0
let denominator_inter.s1.i.min = 0
let denominator_inter.s0.vis.max = 9
let denominator_inter.s0.vis.min = 0
let denominator_inter.s0.i.max = 0
let denominator_inter.s0.i.min = 0
let next.extent.0.required = (((next.extent.0 + next.min.0) + -1) + 1) - next.min.0
let next.min.0.required = next.min.0
let next.stride.0.required = 1
let next.stride.0.constrained = 1
let next.stride.0.proposed = 1
let next.min.0.proposed = next.min.0.required
let next.extent.0.proposed = next.extent.0.required
assert(!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer) || ((next.min.0.proposed <= next.min.0.required) && (((next.min.0.proposed + next.extent.0.proposed) - 1) >= ((next.min.0.required + next.extent.0.required) - 1))), halide_error_constraints_make_required_region_smaller("Output buffer next", 0, next.min.0.proposed, (next.min.0.proposed + next.extent.0.proposed) - 1, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1))
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0.proposed, next.extent.0.proposed, next.stride.0.proposed, 0), (uint64)0)
}
if (!((uint1)0 || (uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer))) {
 assert((uint32)next.type == (uint32)73728, halide_error_bad_type("Output buffer next", (uint32)next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert((next.min.0 <= next.min.0.required) && (((next.min.0 + next.extent.0) - 1) >= ((next.min.0.required + next.extent.0.required) - 1)), halide_error_access_out_of_bounds("Output buffer next", 0, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1, next.min.0, (next.min.0 + next.extent.0) - 1))
 assert(next.extent.0 >= 0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == next.stride.0.constrained, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", next.stride.0.constrained))
 let next.total_extent.0 = int64(next.extent.0)
 assert((uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", (uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)), (uint64)2147483647))
 assert(!(uint1)next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert((void *)next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
 let numerator.si.min_realized = min(next.min.0, 0)
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 realize numerator([numerator.si.min_realized, numerator.si.extent_realized]) {
  let denominator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
  let denominator.si.min_realized = min(next.min.0, 0)
  let denominator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
  let denominator.i.max_realized = 0
  let denominator.i.min_realized = 0
  let denominator.i.extent_realized = 1
  realize denominator([denominator.i.min_realized, denominator.i.extent_realized], [denominator.si.min_realized, denominator.si.extent_realized]) {
   let denominator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
   let denominator.s0.si.loop_min = min(next.min.0, 0)
   let denominator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
   let denominator.s0.i.loop_max = 0
   let denominator.s0.i.loop_min = 0
   let denominator.s0.i.loop_extent = 1
   let numerator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
   let numerator.s0.si.loop_min = min(next.min.0, 0)
   let numerator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
   let numerator.s1.rv$x.loop_extent = 10
   let numerator.s1.rv$x.loop_max = 9
   let numerator.s1.rv$x.loop_min = 0
   let numerator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
   let numerator.s1.si.loop_min = next.min.0
   let numerator.s1.si.loop_extent = next.extent.0
   let denominator.s1.rv$x.loop_extent = 10
   let denominator.s1.rv$x.loop_max = 9
   let denominator.s1.rv$x.loop_min = 0
   let denominator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
   let denominator.s1.si.loop_min = next.min.0
   let denominator.s1.si.loop_extent = next.extent.0
   let denominator.s1.i.loop_max = 0
   let denominator.s1.i.loop_min = 0
   let denominator.s1.i.loop_extent = 1
   produce denominator {
    produce numerator {
     let denominator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (denominator.s0.si, min(next.min.0, 0), denominator.s0.si.loop_extent) {
      let denominator.s0.i.loop_min.orig = 0
      let denominator.s0.i = 0
      denominator(0, denominator.s0.si) = 0
     }
     let numerator.s0.si.loop_min.orig = min(next.min.0, 0)
     for (numerator.s0.si, min(next.min.0, 0), numerator.s0.si.loop_extent) {
      numerator(numerator.s0.si) = 0
     }
     let numerator.s1.rv$x.loop_min.orig = 0
     for (numerator.s1.rv$x, 0, 10) {
      let numerator.s1.rv$x.max_1 = numerator.s1.rv$x
      let numerator.s1.rv$x.min_1 = numerator.s1.rv$x
      let denominator.s1.rv$x.max_1 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_1 = denominator.s1.rv$x
      let numerator.s1.si.min_1 = numerator.s1.rv$x
      let numerator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.si.min_1 = numerator.s1.rv$x
      let denominator.s1.si.max_1 = numerator.s1.rv$x
      let denominator.s1.i.min_1 = 0
      let denominator.s1.i.max_1 = 0
      let denominator_inter.s1.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_1 = 0
      let denominator_inter.s1.i.min_1 = 0
      let denominator_inter.s0.vis.max_1 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_1 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_1 = 0
      let denominator_inter.s0.i.min_1 = 0
      numerator(numerator.s1.rv$x) = numerator(numerator.s1.rv$x) + numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_extent = 1
      let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
      let denominator.s1.fused.rv$x.loop_min.orig = numerator.s1.rv$x
      let denominator.s1.fused.rv$x = numerator.s1.rv$x
      let denominator.s1.i.loop_min.orig = 0
      let denominator.s1.i = 0
      let denominator.s1.rv$x.max_2 = denominator.s1.rv$x
      let denominator.s1.rv$x.min_2 = denominator.s1.rv$x
      let denominator.s1.si.min_2 = numerator.s1.rv$x
      let denominator.s1.si.max_2 = numerator.s1.rv$x
      let denominator.s1.i.min_2 = 0
      let denominator.s1.i.max_2 = 0
      let denominator_inter.s1.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s1.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s1.i.max_2 = 0
      let denominator_inter.s1.i.min_2 = 0
      let denominator_inter.s0.vis.max_2 = denominator.s1.rv$x
      let denominator_inter.s0.vis.min_2 = denominator.s1.rv$x
      let denominator_inter.s0.i.max_2 = 0
      let denominator_inter.s0.i.min_2 = 0
      let denominator_inter.vis.max_realized = max(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
      let denominator_inter.vis.extent_realized = max(max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x), 0) + 1
      let denominator_inter.i.max_realized = 0
      let denominator_inter.i.min_realized = 0
      let denominator_inter.i.extent_realized = 1
      realize denominator_inter([denominator_inter.i.min_realized, denominator_inter.i.extent_realized], [denominator_inter.vis.min_realized, denominator_inter.vis.extent_realized]) {
       let denominator_inter.s0.vis.loop_max = denominator.s1.rv$x
       let denominator_inter.s0.vis.loop_min = denominator.s1.rv$x
       let denominator_inter.s0.vis.loop_extent = 1
       let denominator_inter.s0.i.loop_max = 0
       let denominator_inter.s0.i.loop_min = 0
       let denominator_inter.s0.i.loop_extent = 1
       let denominator_inter.s1.vis.loop_max = denominator.s1.rv$x
       let denominator_inter.s1.vis.loop_min = denominator.s1.rv$x
       let denominator_inter.s1.vis.loop_extent = 1
       let denominator_inter.s1.i.loop_max = 0
       let denominator_inter.s1.i.loop_min = 0
       let denominator_inter.s1.i.loop_extent = 1
       let t4 = denominator.s1.rv$x
       let t3 = denominator.s1.rv$x
       produce denominator_inter {
        let denominator_inter.s0.i.loop_min.orig = 0
        let denominator_inter.s0.i = 0
        denominator_inter(0, denominator.s1.rv$x) = 0
        denominator_inter(0, denominator.s1.rv$x) = denominator.s1.rv$x
       }
       consume denominator_inter {
        denominator(0, numerator.s1.rv$x) = denominator(0, numerator.s1.rv$x) + denominator_inter(0, numerator.s1.rv$x)
       }
      }
     }
    }
   }
   let next.s0.si.loop_max = (next.extent.0 + next.min.0) + -1
   let next.s0.si.loop_min = next.min.0
   let next.s0.si.loop_extent = next.extent.0
   let next.s0.si.loop_min.orig = next.min.0
   produce next {
    consume denominator {
     consume numerator {
      for (next.s0.si, next.min.0, next.extent.0) {
       next(next.s0.si) = numerator(next.s0.si)/denominator(0, next.s0.si)
      }
     }
    }
   }
  }
 }
}

Performing storage flattening...
 load call to numerator 0
 load call to denominator 0
 load call to denominator_inter 0
 load call to numerator 0
 load call to denominator 0
Lowering after storage flattening:
let next.s0.si.max = (next.extent.0 + next.min.0) + -1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = 9
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = (next.extent.0 + next.min.0) + -1
let numerator.s1.si.min = next.min.0
let numerator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let numerator.s0.si.min = min(next.min.0, 0)
let denominator.s1.rv$x.max = 9
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = (next.extent.0 + next.min.0) + -1
let denominator.s1.si.min = next.min.0
let denominator.s1.i.max = 0
let denominator.s1.i.min = 0
let denominator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let denominator.s0.si.min = min(next.min.0, 0)
let denominator.s0.i.max = 0
let denominator.s0.i.min = 0
let denominator_inter.s1.vis.max = 9
let denominator_inter.s1.vis.min = 0
let denominator_inter.s1.i.max = 0
let denominator_inter.s1.i.min = 0
let denominator_inter.s0.vis.max = 9
let denominator_inter.s0.vis.min = 0
let denominator_inter.s0.i.max = 0
let denominator_inter.s0.i.min = 0
let next.extent.0.required = (((next.extent.0 + next.min.0) + -1) + 1) - next.min.0
let next.min.0.required = next.min.0
let next.stride.0.required = 1
let next.stride.0.constrained = 1
let next.stride.0.proposed = 1
let next.min.0.proposed = next.min.0.required
let next.extent.0.proposed = next.extent.0.required
assert(!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer) || ((next.min.0.proposed <= next.min.0.required) && (((next.min.0.proposed + next.extent.0.proposed) - 1) >= ((next.min.0.required + next.extent.0.required) - 1))), halide_error_constraints_make_required_region_smaller("Output buffer next", 0, next.min.0.proposed, (next.min.0.proposed + next.extent.0.proposed) - 1, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1))
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0.proposed, next.extent.0.proposed, next.stride.0.proposed, 0), (uint64)0)
}
if (!((uint1)0 || (uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer))) {
 assert((uint32)next.type == (uint32)73728, halide_error_bad_type("Output buffer next", (uint32)next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert((next.min.0 <= next.min.0.required) && (((next.min.0 + next.extent.0) - 1) >= ((next.min.0.required + next.extent.0.required) - 1)), halide_error_access_out_of_bounds("Output buffer next", 0, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1, next.min.0, (next.min.0 + next.extent.0) - 1))
 assert(next.extent.0 >= 0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == next.stride.0.constrained, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", next.stride.0.constrained))
 let next.total_extent.0 = int64(next.extent.0)
 assert((uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", (uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)), (uint64)2147483647))
 assert(!(uint1)next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert((void *)next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
 let numerator.si.min_realized = min(next.min.0, 0)
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 let numerator.extent.0 = numerator.si.extent_realized
 let numerator.min.0 = numerator.si.min_realized
 let numerator.stride.0 = 1
 allocate numerator[int32 * numerator.si.extent_realized]
 let numerator.buffer = let t8 = (struct halide_dimension_t *)make_struct(numerator.min.0, numerator.extent.0, numerator.stride.0, 0) in (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)alloca(size_of_halide_buffer_t()), t8, numerator, (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, t8, (uint64)0)
 let denominator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
 let denominator.si.min_realized = min(next.min.0, 0)
 let denominator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 let denominator.i.max_realized = 0
 let denominator.i.min_realized = 0
 let denominator.i.extent_realized = 1
 let denominator.extent.0 = denominator.i.extent_realized
 let denominator.min.0 = denominator.i.min_realized
 let denominator.extent.1 = denominator.si.extent_realized
 let denominator.min.1 = denominator.si.min_realized
 let denominator.stride.0 = 1
 let denominator.stride.1 = denominator.stride.0*denominator.i.extent_realized
 allocate denominator[int32 * denominator.i.extent_realized * denominator.si.extent_realized]
 let denominator.buffer = let t7 = (struct halide_dimension_t *)make_struct(denominator.min.0, denominator.extent.0, denominator.stride.0, 0, denominator.min.1, denominator.extent.1, denominator.stride.1, 0) in (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)alloca(size_of_halide_buffer_t()), t7, denominator, (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 2, t7, (uint64)0)
 let denominator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
 let denominator.s0.si.loop_min = min(next.min.0, 0)
 let denominator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 let denominator.s0.i.loop_max = 0
 let denominator.s0.i.loop_min = 0
 let denominator.s0.i.loop_extent = 1
 let numerator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
 let numerator.s0.si.loop_min = min(next.min.0, 0)
 let numerator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 let numerator.s1.rv$x.loop_extent = 10
 let numerator.s1.rv$x.loop_max = 9
 let numerator.s1.rv$x.loop_min = 0
 let numerator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
 let numerator.s1.si.loop_min = next.min.0
 let numerator.s1.si.loop_extent = next.extent.0
 let denominator.s1.rv$x.loop_extent = 10
 let denominator.s1.rv$x.loop_max = 9
 let denominator.s1.rv$x.loop_min = 0
 let denominator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
 let denominator.s1.si.loop_min = next.min.0
 let denominator.s1.si.loop_extent = next.extent.0
 let denominator.s1.i.loop_max = 0
 let denominator.s1.i.loop_min = 0
 let denominator.s1.i.loop_extent = 1
 produce denominator {
  produce numerator {
   let denominator.s0.si.loop_min.orig = min(next.min.0, 0)
   for (denominator.s0.si, min(next.min.0, 0), denominator.s0.si.loop_extent) {
    let denominator.s0.i.loop_min.orig = 0
    let denominator.s0.i = 0
    denominator[(0 + ((0 - denominator.min.0)*denominator.stride.0)) + ((denominator.s0.si - denominator.min.1)*denominator.stride.1)] = 0
   }
   let numerator.s0.si.loop_min.orig = min(next.min.0, 0)
   for (numerator.s0.si, min(next.min.0, 0), numerator.s0.si.loop_extent) {
    numerator[0 + ((numerator.s0.si - numerator.min.0)*numerator.stride.0)] = 0
   }
   let numerator.s1.rv$x.loop_min.orig = 0
   for (numerator.s1.rv$x, 0, 10) {
    let numerator.s1.rv$x.max_1 = numerator.s1.rv$x
    let numerator.s1.rv$x.min_1 = numerator.s1.rv$x
    let denominator.s1.rv$x.max_1 = denominator.s1.rv$x
    let denominator.s1.rv$x.min_1 = denominator.s1.rv$x
    let numerator.s1.si.min_1 = numerator.s1.rv$x
    let numerator.s1.si.max_1 = numerator.s1.rv$x
    let denominator.s1.si.min_1 = numerator.s1.rv$x
    let denominator.s1.si.max_1 = numerator.s1.rv$x
    let denominator.s1.i.min_1 = 0
    let denominator.s1.i.max_1 = 0
    let denominator_inter.s1.vis.max_1 = denominator.s1.rv$x
    let denominator_inter.s1.vis.min_1 = denominator.s1.rv$x
    let denominator_inter.s1.i.max_1 = 0
    let denominator_inter.s1.i.min_1 = 0
    let denominator_inter.s0.vis.max_1 = denominator.s1.rv$x
    let denominator_inter.s0.vis.min_1 = denominator.s1.rv$x
    let denominator_inter.s0.i.max_1 = 0
    let denominator_inter.s0.i.min_1 = 0
    numerator[0 + ((numerator.s1.rv$x - numerator.min.0)*numerator.stride.0)] = numerator[0 + ((numerator.s1.rv$x - numerator.min.0)*numerator.stride.0)] + numerator.s1.rv$x
    let denominator.s1.fused.rv$x.loop_extent = 1
    let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
    let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
    let denominator.s1.fused.rv$x.loop_min.orig = numerator.s1.rv$x
    let denominator.s1.fused.rv$x = numerator.s1.rv$x
    let denominator.s1.i.loop_min.orig = 0
    let denominator.s1.i = 0
    let denominator.s1.rv$x.max_2 = denominator.s1.rv$x
    let denominator.s1.rv$x.min_2 = denominator.s1.rv$x
    let denominator.s1.si.min_2 = numerator.s1.rv$x
    let denominator.s1.si.max_2 = numerator.s1.rv$x
    let denominator.s1.i.min_2 = 0
    let denominator.s1.i.max_2 = 0
    let denominator_inter.s1.vis.max_2 = denominator.s1.rv$x
    let denominator_inter.s1.vis.min_2 = denominator.s1.rv$x
    let denominator_inter.s1.i.max_2 = 0
    let denominator_inter.s1.i.min_2 = 0
    let denominator_inter.s0.vis.max_2 = denominator.s1.rv$x
    let denominator_inter.s0.vis.min_2 = denominator.s1.rv$x
    let denominator_inter.s0.i.max_2 = 0
    let denominator_inter.s0.i.min_2 = 0
    let denominator_inter.vis.max_realized = max(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized = max(max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x), 0) + 1
    let denominator_inter.i.max_realized = 0
    let denominator_inter.i.min_realized = 0
    let denominator_inter.i.extent_realized = 1
    let denominator_inter.extent.0 = denominator_inter.i.extent_realized
    let denominator_inter.min.0 = denominator_inter.i.min_realized
    let denominator_inter.extent.1 = denominator_inter.vis.extent_realized
    let denominator_inter.min.1 = denominator_inter.vis.min_realized
    let denominator_inter.stride.0 = 1
    let denominator_inter.stride.1 = denominator_inter.stride.0*denominator_inter.i.extent_realized
    allocate denominator_inter[int32 * denominator_inter.i.extent_realized * denominator_inter.vis.extent_realized]
    let denominator_inter.buffer = let t6 = (struct halide_dimension_t *)make_struct(denominator_inter.min.0, denominator_inter.extent.0, denominator_inter.stride.0, 0, denominator_inter.min.1, denominator_inter.extent.1, denominator_inter.stride.1, 0) in (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)alloca(size_of_halide_buffer_t()), t6, denominator_inter, (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 2, t6, (uint64)0)
    let denominator_inter.s0.vis.loop_max = denominator.s1.rv$x
    let denominator_inter.s0.vis.loop_min = denominator.s1.rv$x
    let denominator_inter.s0.vis.loop_extent = 1
    let denominator_inter.s0.i.loop_max = 0
    let denominator_inter.s0.i.loop_min = 0
    let denominator_inter.s0.i.loop_extent = 1
    let denominator_inter.s1.vis.loop_max = denominator.s1.rv$x
    let denominator_inter.s1.vis.loop_min = denominator.s1.rv$x
    let denominator_inter.s1.vis.loop_extent = 1
    let denominator_inter.s1.i.loop_max = 0
    let denominator_inter.s1.i.loop_min = 0
    let denominator_inter.s1.i.loop_extent = 1
    let t4 = denominator.s1.rv$x
    let t3 = denominator.s1.rv$x
    produce denominator_inter {
     let denominator_inter.s0.i.loop_min.orig = 0
     let denominator_inter.s0.i = 0
     denominator_inter[(0 + ((0 - denominator_inter.min.0)*denominator_inter.stride.0)) + ((denominator.s1.rv$x - denominator_inter.min.1)*denominator_inter.stride.1)] = 0
     denominator_inter[(0 + ((0 - denominator_inter.min.0)*denominator_inter.stride.0)) + ((denominator.s1.rv$x - denominator_inter.min.1)*denominator_inter.stride.1)] = denominator.s1.rv$x
    }
    consume denominator_inter {
     denominator[(0 + ((0 - denominator.min.0)*denominator.stride.0)) + ((numerator.s1.rv$x - denominator.min.1)*denominator.stride.1)] = denominator[(0 + ((0 - denominator.min.0)*denominator.stride.0)) + ((numerator.s1.rv$x - denominator.min.1)*denominator.stride.1)] + denominator_inter[(0 + ((0 - denominator_inter.min.0)*denominator_inter.stride.0)) + ((numerator.s1.rv$x - denominator_inter.min.1)*denominator_inter.stride.1)]
    }
   }
  }
 }
 let next.s0.si.loop_max = (next.extent.0 + next.min.0) + -1
 let next.s0.si.loop_min = next.min.0
 let next.s0.si.loop_extent = next.extent.0
 let next.s0.si.loop_min.orig = next.min.0
 produce next {
  consume denominator {
   consume numerator {
    for (next.s0.si, next.min.0, next.extent.0) {
     next[(0 + (next.s0.si*next.stride.0)) - (0 + (next.min.0*next.stride.0))] = numerator[0 + ((next.s0.si - numerator.min.0)*numerator.stride.0)]/denominator[(0 + ((0 - denominator.min.0)*denominator.stride.0)) + ((next.s0.si - denominator.min.1)*denominator.stride.1)]
    }
   }
  }
 }
}

Adding atomic mutex allocation...
Lowering after adding atomic mutex allocation: (unchanged)

Unpacking buffer arguments...
Lowering after unpacking buffer arguments:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
let next.s0.si.max = (next.extent.0 + next.min.0) + -1
let next.s0.si.min = next.min.0
let numerator.s1.rv$x.max = 9
let numerator.s1.rv$x.min = 0
let numerator.s1.si.max = (next.extent.0 + next.min.0) + -1
let numerator.s1.si.min = next.min.0
let numerator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let numerator.s0.si.min = min(next.min.0, 0)
let denominator.s1.rv$x.max = 9
let denominator.s1.rv$x.min = 0
let denominator.s1.si.max = (next.extent.0 + next.min.0) + -1
let denominator.s1.si.min = next.min.0
let denominator.s1.i.max = 0
let denominator.s1.i.min = 0
let denominator.s0.si.max = max(next.extent.0 + next.min.0, 10) + -1
let denominator.s0.si.min = min(next.min.0, 0)
let denominator.s0.i.max = 0
let denominator.s0.i.min = 0
let denominator_inter.s1.vis.max = 9
let denominator_inter.s1.vis.min = 0
let denominator_inter.s1.i.max = 0
let denominator_inter.s1.i.min = 0
let denominator_inter.s0.vis.max = 9
let denominator_inter.s0.vis.min = 0
let denominator_inter.s0.i.max = 0
let denominator_inter.s0.i.min = 0
let next.extent.0.required = (((next.extent.0 + next.min.0) + -1) + 1) - next.min.0
let next.min.0.required = next.min.0
let next.stride.0.required = 1
let next.stride.0.constrained = 1
let next.stride.0.proposed = 1
let next.min.0.proposed = next.min.0.required
let next.extent.0.proposed = next.extent.0.required
assert(!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer) || ((next.min.0.proposed <= next.min.0.required) && (((next.min.0.proposed + next.extent.0.proposed) - 1) >= ((next.min.0.required + next.extent.0.required) - 1))), halide_error_constraints_make_required_region_smaller("Output buffer next", 0, next.min.0.proposed, (next.min.0.proposed + next.extent.0.proposed) - 1, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1))
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0.proposed, next.extent.0.proposed, next.stride.0.proposed, 0), (uint64)0)
}
if (!((uint1)0 || (uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer))) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert((next.min.0 <= next.min.0.required) && (((next.min.0 + next.extent.0) - 1) >= ((next.min.0.required + next.extent.0.required) - 1)), halide_error_access_out_of_bounds("Output buffer next", 0, next.min.0.required, (next.min.0.required + next.extent.0.required) - 1, next.min.0, (next.min.0 + next.extent.0) - 1))
 assert(next.extent.0 >= 0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == next.stride.0.constrained, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", next.stride.0.constrained))
 let next.total_extent.0 = int64(next.extent.0)
 assert((uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", (uint64)abs(int64(next.extent.0)*int64(next.stride.0.constrained)), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
 let numerator.si.min_realized = min(next.min.0, 0)
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 let numerator.extent.0 = numerator.si.extent_realized
 let numerator.min.0 = numerator.si.min_realized
 let numerator.stride.0 = 1
 allocate numerator[int32 * numerator.si.extent_realized]
 let numerator.buffer = let t8 = (struct halide_dimension_t *)make_struct(numerator.min.0, numerator.extent.0, numerator.stride.0, 0) in (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)alloca(size_of_halide_buffer_t()), t8, numerator, (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, t8, (uint64)0)
 let denominator.si.max_realized = max(next.extent.0 + next.min.0, 10) + -1
 let denominator.si.min_realized = min(next.min.0, 0)
 let denominator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 let denominator.i.max_realized = 0
 let denominator.i.min_realized = 0
 let denominator.i.extent_realized = 1
 let denominator.extent.0 = denominator.i.extent_realized
 let denominator.min.0 = denominator.i.min_realized
 let denominator.extent.1 = denominator.si.extent_realized
 let denominator.min.1 = denominator.si.min_realized
 let denominator.stride.0 = 1
 let denominator.stride.1 = denominator.stride.0*denominator.i.extent_realized
 allocate denominator[int32 * denominator.i.extent_realized * denominator.si.extent_realized]
 let denominator.buffer = let t7 = (struct halide_dimension_t *)make_struct(denominator.min.0, denominator.extent.0, denominator.stride.0, 0, denominator.min.1, denominator.extent.1, denominator.stride.1, 0) in (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)alloca(size_of_halide_buffer_t()), t7, denominator, (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 2, t7, (uint64)0)
 let denominator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
 let denominator.s0.si.loop_min = min(next.min.0, 0)
 let denominator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 let denominator.s0.i.loop_max = 0
 let denominator.s0.i.loop_min = 0
 let denominator.s0.i.loop_extent = 1
 let numerator.s0.si.loop_max = max(next.extent.0 + next.min.0, 10) + -1
 let numerator.s0.si.loop_min = min(next.min.0, 0)
 let numerator.s0.si.loop_extent = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 let numerator.s1.rv$x.loop_extent = 10
 let numerator.s1.rv$x.loop_max = 9
 let numerator.s1.rv$x.loop_min = 0
 let numerator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
 let numerator.s1.si.loop_min = next.min.0
 let numerator.s1.si.loop_extent = next.extent.0
 let denominator.s1.rv$x.loop_extent = 10
 let denominator.s1.rv$x.loop_max = 9
 let denominator.s1.rv$x.loop_min = 0
 let denominator.s1.si.loop_max = (next.extent.0 + next.min.0) + -1
 let denominator.s1.si.loop_min = next.min.0
 let denominator.s1.si.loop_extent = next.extent.0
 let denominator.s1.i.loop_max = 0
 let denominator.s1.i.loop_min = 0
 let denominator.s1.i.loop_extent = 1
 produce denominator {
  produce numerator {
   let denominator.s0.si.loop_min.orig = min(next.min.0, 0)
   for (denominator.s0.si, min(next.min.0, 0), denominator.s0.si.loop_extent) {
    let denominator.s0.i.loop_min.orig = 0
    let denominator.s0.i = 0
    denominator[(0 + ((0 - denominator.min.0)*denominator.stride.0)) + ((denominator.s0.si - denominator.min.1)*denominator.stride.1)] = 0
   }
   let numerator.s0.si.loop_min.orig = min(next.min.0, 0)
   for (numerator.s0.si, min(next.min.0, 0), numerator.s0.si.loop_extent) {
    numerator[0 + ((numerator.s0.si - numerator.min.0)*numerator.stride.0)] = 0
   }
   let numerator.s1.rv$x.loop_min.orig = 0
   for (numerator.s1.rv$x, 0, 10) {
    let numerator.s1.rv$x.max_1 = numerator.s1.rv$x
    let numerator.s1.rv$x.min_1 = numerator.s1.rv$x
    let denominator.s1.rv$x.max_1 = denominator.s1.rv$x
    let denominator.s1.rv$x.min_1 = denominator.s1.rv$x
    let numerator.s1.si.min_1 = numerator.s1.rv$x
    let numerator.s1.si.max_1 = numerator.s1.rv$x
    let denominator.s1.si.min_1 = numerator.s1.rv$x
    let denominator.s1.si.max_1 = numerator.s1.rv$x
    let denominator.s1.i.min_1 = 0
    let denominator.s1.i.max_1 = 0
    let denominator_inter.s1.vis.max_1 = denominator.s1.rv$x
    let denominator_inter.s1.vis.min_1 = denominator.s1.rv$x
    let denominator_inter.s1.i.max_1 = 0
    let denominator_inter.s1.i.min_1 = 0
    let denominator_inter.s0.vis.max_1 = denominator.s1.rv$x
    let denominator_inter.s0.vis.min_1 = denominator.s1.rv$x
    let denominator_inter.s0.i.max_1 = 0
    let denominator_inter.s0.i.min_1 = 0
    numerator[0 + ((numerator.s1.rv$x - numerator.min.0)*numerator.stride.0)] = numerator[0 + ((numerator.s1.rv$x - numerator.min.0)*numerator.stride.0)] + numerator.s1.rv$x
    let denominator.s1.fused.rv$x.loop_extent = 1
    let denominator.s1.fused.rv$x.loop_max = numerator.s1.rv$x
    let denominator.s1.fused.rv$x.loop_min = numerator.s1.rv$x
    let denominator.s1.fused.rv$x.loop_min.orig = numerator.s1.rv$x
    let denominator.s1.fused.rv$x = numerator.s1.rv$x
    let denominator.s1.i.loop_min.orig = 0
    let denominator.s1.i = 0
    let denominator.s1.rv$x.max_2 = denominator.s1.rv$x
    let denominator.s1.rv$x.min_2 = denominator.s1.rv$x
    let denominator.s1.si.min_2 = numerator.s1.rv$x
    let denominator.s1.si.max_2 = numerator.s1.rv$x
    let denominator.s1.i.min_2 = 0
    let denominator.s1.i.max_2 = 0
    let denominator_inter.s1.vis.max_2 = denominator.s1.rv$x
    let denominator_inter.s1.vis.min_2 = denominator.s1.rv$x
    let denominator_inter.s1.i.max_2 = 0
    let denominator_inter.s1.i.min_2 = 0
    let denominator_inter.s0.vis.max_2 = denominator.s1.rv$x
    let denominator_inter.s0.vis.min_2 = denominator.s1.rv$x
    let denominator_inter.s0.i.max_2 = 0
    let denominator_inter.s0.i.min_2 = 0
    let denominator_inter.vis.max_realized = max(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized = max(max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x), 0) + 1
    let denominator_inter.i.max_realized = 0
    let denominator_inter.i.min_realized = 0
    let denominator_inter.i.extent_realized = 1
    let denominator_inter.extent.0 = denominator_inter.i.extent_realized
    let denominator_inter.min.0 = denominator_inter.i.min_realized
    let denominator_inter.extent.1 = denominator_inter.vis.extent_realized
    let denominator_inter.min.1 = denominator_inter.vis.min_realized
    let denominator_inter.stride.0 = 1
    let denominator_inter.stride.1 = denominator_inter.stride.0*denominator_inter.i.extent_realized
    allocate denominator_inter[int32 * denominator_inter.i.extent_realized * denominator_inter.vis.extent_realized]
    let denominator_inter.buffer = let t6 = (struct halide_dimension_t *)make_struct(denominator_inter.min.0, denominator_inter.extent.0, denominator_inter.stride.0, 0, denominator_inter.min.1, denominator_inter.extent.1, denominator_inter.stride.1, 0) in (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)alloca(size_of_halide_buffer_t()), t6, denominator_inter, (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 2, t6, (uint64)0)
    let denominator_inter.s0.vis.loop_max = denominator.s1.rv$x
    let denominator_inter.s0.vis.loop_min = denominator.s1.rv$x
    let denominator_inter.s0.vis.loop_extent = 1
    let denominator_inter.s0.i.loop_max = 0
    let denominator_inter.s0.i.loop_min = 0
    let denominator_inter.s0.i.loop_extent = 1
    let denominator_inter.s1.vis.loop_max = denominator.s1.rv$x
    let denominator_inter.s1.vis.loop_min = denominator.s1.rv$x
    let denominator_inter.s1.vis.loop_extent = 1
    let denominator_inter.s1.i.loop_max = 0
    let denominator_inter.s1.i.loop_min = 0
    let denominator_inter.s1.i.loop_extent = 1
    let t4 = denominator.s1.rv$x
    let t3 = denominator.s1.rv$x
    produce denominator_inter {
     let denominator_inter.s0.i.loop_min.orig = 0
     let denominator_inter.s0.i = 0
     denominator_inter[(0 + ((0 - denominator_inter.min.0)*denominator_inter.stride.0)) + ((denominator.s1.rv$x - denominator_inter.min.1)*denominator_inter.stride.1)] = 0
     denominator_inter[(0 + ((0 - denominator_inter.min.0)*denominator_inter.stride.0)) + ((denominator.s1.rv$x - denominator_inter.min.1)*denominator_inter.stride.1)] = denominator.s1.rv$x
    }
    consume denominator_inter {
     denominator[(0 + ((0 - denominator.min.0)*denominator.stride.0)) + ((numerator.s1.rv$x - denominator.min.1)*denominator.stride.1)] = denominator[(0 + ((0 - denominator.min.0)*denominator.stride.0)) + ((numerator.s1.rv$x - denominator.min.1)*denominator.stride.1)] + denominator_inter[(0 + ((0 - denominator_inter.min.0)*denominator_inter.stride.0)) + ((numerator.s1.rv$x - denominator_inter.min.1)*denominator_inter.stride.1)]
    }
   }
  }
 }
 let next.s0.si.loop_max = (next.extent.0 + next.min.0) + -1
 let next.s0.si.loop_min = next.min.0
 let next.s0.si.loop_extent = next.extent.0
 let next.s0.si.loop_min.orig = next.min.0
 produce next {
  consume denominator {
   consume numerator {
    for (next.s0.si, next.min.0, next.extent.0) {
     next[(0 + (next.s0.si*next.stride.0)) - (0 + (next.min.0*next.stride.0))] = numerator[0 + ((next.s0.si - numerator.min.0)*numerator.stride.0)]/denominator[(0 + ((0 - denominator.min.0)*denominator.stride.0)) + ((next.s0.si - denominator.min.1)*denominator.stride.1)]
    }
   }
  }
 }
}

Skipping rewriting memoized allocations...
Simplifying...
Lowering after second simplifcation:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 0
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(int64(next.extent.0)) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(int64(next.extent.0)), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 let denominator.si.extent_realized = numerator.si.extent_realized
 allocate denominator[int32 * 1 * denominator.si.extent_realized]
 let denominator.s0.si.loop_extent = denominator.si.extent_realized
 let numerator.s0.si.loop_extent = denominator.si.extent_realized
 produce denominator {
  produce numerator {
   for (denominator.s0.si, min(next.min.0, 0), denominator.si.extent_realized) {
    denominator[denominator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s0.si, min(next.min.0, 0), denominator.si.extent_realized) {
    numerator[numerator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s1.rv$x, 0, 10) {
    numerator[numerator.s1.rv$x - min(next.min.0, 0)] = numerator[numerator.s1.rv$x - min(next.min.0, 0)] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s = max(denominator.s1.rv$x, numerator.s1.rv$x) - denominator_inter.vis.min_realized
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     denominator[numerator.s1.rv$x - min(next.min.0, 0)] = denominator[numerator.s1.rv$x - min(next.min.0, 0)] + denominator_inter[numerator.s1.rv$x - denominator_inter.vis.min_realized]
    }
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    for (next.s0.si, next.min.0, next.extent.0) {
     next[next.s0.si - next.min.0] = numerator[next.s0.si - min(next.min.0, 0)]/denominator[next.s0.si - min(next.min.0, 0)]
    }
   }
  }
 }
}

Reduce prefetch dimension...
Lowering after reduce prefetch dimension: (unchanged)

Simplifying correlated differences...
Warning: expression is non-monotonic in loop variable numerator.s1.rv$x: max(max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x), 0)
Lowering after simplifying correlated differences:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 0
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(int64(next.extent.0)) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(int64(next.extent.0)), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 let denominator.si.extent_realized = numerator.si.extent_realized
 allocate denominator[int32 * 1 * denominator.si.extent_realized]
 let denominator.s0.si.loop_extent = denominator.si.extent_realized
 let numerator.s0.si.loop_extent = denominator.si.extent_realized
 produce denominator {
  produce numerator {
   for (denominator.s0.si, min(next.min.0, 0), denominator.si.extent_realized) {
    denominator[denominator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s0.si, min(next.min.0, 0), denominator.si.extent_realized) {
    numerator[numerator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s1.rv$x, 0, 10) {
    numerator[numerator.s1.rv$x - min(next.min.0, 0)] = numerator[numerator.s1.rv$x - min(next.min.0, 0)] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s = max(max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x), 0)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     denominator[numerator.s1.rv$x - min(next.min.0, 0)] = denominator[numerator.s1.rv$x - min(next.min.0, 0)] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    for (next.s0.si, next.min.0, next.extent.0) {
     next[next.s0.si - next.min.0] = numerator[next.s0.si - min(next.min.0, 0)]/denominator[next.s0.si - min(next.min.0, 0)]
    }
   }
  }
 }
}

Unrolling...
Lowering after unrolling: (unchanged)

Vectorizing...
Lowering after vectorizing:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si, min(next.min.0, 0), numerator.si.extent_realized) {
    denominator[denominator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s0.si, min(next.min.0, 0), numerator.si.extent_realized) {
    numerator[numerator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s1.rv$x, 0, 10) {
    numerator[numerator.s1.rv$x - min(next.min.0, 0)] = numerator[numerator.s1.rv$x - min(next.min.0, 0)] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s = max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     denominator[numerator.s1.rv$x - min(next.min.0, 0)] = denominator[numerator.s1.rv$x - min(next.min.0, 0)] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    for (next.s0.si, next.min.0, next.extent.0) {
     next[next.s0.si - next.min.0] = numerator[next.s0.si - min(next.min.0, 0)]/denominator[next.s0.si - min(next.min.0, 0)]
    }
   }
  }
 }
}

Detecting vector interleavings...
Lowering after rewriting vector interleavings:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si, min(next.min.0, 0), numerator.si.extent_realized) {
    denominator[denominator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s0.si, min(next.min.0, 0), numerator.si.extent_realized) {
    numerator[numerator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s1.rv$x, 0, 10) {
    numerator[numerator.s1.rv$x - min(next.min.0, 0)] = numerator[numerator.s1.rv$x - min(next.min.0, 0)] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s = max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     denominator[numerator.s1.rv$x - min(next.min.0, 0)] = denominator[numerator.s1.rv$x - min(next.min.0, 0)] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    for (next.s0.si, next.min.0, next.extent.0) {
     next[next.s0.si - next.min.0] = numerator[next.s0.si - min(next.min.0, 0)]/denominator[next.s0.si - min(next.min.0, 0)]
    }
   }
  }
 }
}

Partitioning loops to simplify boundary conditions...
Lowering after partitioning loops:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si, min(next.min.0, 0), numerator.si.extent_realized) {
    denominator[denominator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s0.si, min(next.min.0, 0), numerator.si.extent_realized) {
    numerator[numerator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s1.rv$x, 0, 10) {
    numerator[numerator.s1.rv$x - min(next.min.0, 0)] = numerator[numerator.s1.rv$x - min(next.min.0, 0)] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s = max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     denominator[numerator.s1.rv$x - min(next.min.0, 0)] = denominator[numerator.s1.rv$x - min(next.min.0, 0)] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    for (next.s0.si, next.min.0, next.extent.0) {
     next[next.s0.si - next.min.0] = numerator[next.s0.si - min(next.min.0, 0)]/denominator[next.s0.si - min(next.min.0, 0)]
    }
   }
  }
 }
}

Staging strided loads...
Lowering after staging strided loads: (unchanged)

Trimming loops to the region over which they do something...
Lowering after loop trimming: (unchanged)

Rebasing loops to zero...
Lowering after rebasing loops to zero:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si.rebased, 0, numerator.si.extent_realized) {
    let denominator.s0.si = denominator.s0.si.rebased + min(next.min.0, 0)
    denominator[denominator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s0.si.rebased, 0, numerator.si.extent_realized) {
    let numerator.s0.si = numerator.s0.si.rebased + min(next.min.0, 0)
    numerator[numerator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s1.rv$x, 0, 10) {
    numerator[numerator.s1.rv$x - min(next.min.0, 0)] = numerator[numerator.s1.rv$x - min(next.min.0, 0)] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s = max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     denominator[numerator.s1.rv$x - min(next.min.0, 0)] = denominator[numerator.s1.rv$x - min(next.min.0, 0)] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    for (next.s0.si.rebased, 0, next.extent.0) {
     let next.s0.si = next.s0.si.rebased + next.min.0
     next[next.s0.si - next.min.0] = numerator[next.s0.si - min(next.min.0, 0)]/denominator[next.s0.si - min(next.min.0, 0)]
    }
   }
  }
 }
}


Hoisting loop invariant if statements...
Lowering after hoisting loop invariant if statements:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si.rebased, 0, numerator.si.extent_realized) {
    let denominator.s0.si = denominator.s0.si.rebased + min(next.min.0, 0)
    denominator[denominator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s0.si.rebased, 0, numerator.si.extent_realized) {
    let numerator.s0.si = numerator.s0.si.rebased + min(next.min.0, 0)
    numerator[numerator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s1.rv$x, 0, 10) {
    numerator[numerator.s1.rv$x - min(next.min.0, 0)] = numerator[numerator.s1.rv$x - min(next.min.0, 0)] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s = max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     denominator[numerator.s1.rv$x - min(next.min.0, 0)] = denominator[numerator.s1.rv$x - min(next.min.0, 0)] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    for (next.s0.si.rebased, 0, next.extent.0) {
     let next.s0.si = next.s0.si.rebased + next.min.0
     next[next.s0.si - next.min.0] = numerator[next.s0.si - min(next.min.0, 0)]/denominator[next.s0.si - min(next.min.0, 0)]
    }
   }
  }
 }
}

Injecting early frees...
Lowering after injecting early frees:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si.rebased, 0, numerator.si.extent_realized) {
    let denominator.s0.si = denominator.s0.si.rebased + min(next.min.0, 0)
    denominator[denominator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s0.si.rebased, 0, numerator.si.extent_realized) {
    let numerator.s0.si = numerator.s0.si.rebased + min(next.min.0, 0)
    numerator[numerator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s1.rv$x, 0, 10) {
    numerator[numerator.s1.rv$x - min(next.min.0, 0)] = numerator[numerator.s1.rv$x - min(next.min.0, 0)] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s = max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     denominator[numerator.s1.rv$x - min(next.min.0, 0)] = denominator[numerator.s1.rv$x - min(next.min.0, 0)] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
    free denominator_inter
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    for (next.s0.si.rebased, 0, next.extent.0) {
     let next.s0.si = next.s0.si.rebased + next.min.0
     next[next.s0.si - next.min.0] = numerator[next.s0.si - min(next.min.0, 0)]/denominator[next.s0.si - min(next.min.0, 0)]
    }
   }
  }
 }
 free numerator
 free denominator
}

Simplifying correlated differences...
Warning: expression is non-monotonic in loop variable numerator.s1.rv$x: max(max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x), 0)
Lowering after simplifying correlated differences:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si.rebased, 0, numerator.si.extent_realized) {
    let denominator.s0.si = denominator.s0.si.rebased + min(next.min.0, 0)
    denominator[denominator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s0.si.rebased, 0, numerator.si.extent_realized) {
    let numerator.s0.si = numerator.s0.si.rebased + min(next.min.0, 0)
    numerator[numerator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s1.rv$x, 0, 10) {
    numerator[numerator.s1.rv$x - min(next.min.0, 0)] = numerator[numerator.s1.rv$x - min(next.min.0, 0)] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s = max(max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x), 0)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     denominator[numerator.s1.rv$x - min(next.min.0, 0)] = denominator[numerator.s1.rv$x - min(next.min.0, 0)] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
    free denominator_inter
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    for (next.s0.si.rebased, 0, next.extent.0) {
     let next.s0.si = next.s0.si.rebased + next.min.0
     next[next.s0.si - next.min.0] = numerator[next.s0.si - min(next.min.0, 0)]/denominator[next.s0.si - min(next.min.0, 0)]
    }
   }
  }
 }
 free numerator
 free denominator
}

Bounding small allocations...
Lowering after bounding small allocations:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si.rebased, 0, numerator.si.extent_realized) {
    let denominator.s0.si = denominator.s0.si.rebased + min(next.min.0, 0)
    denominator[denominator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s0.si.rebased, 0, numerator.si.extent_realized) {
    let numerator.s0.si = numerator.s0.si.rebased + min(next.min.0, 0)
    numerator[numerator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s1.rv$x, 0, 10) {
    numerator[numerator.s1.rv$x - min(next.min.0, 0)] = numerator[numerator.s1.rv$x - min(next.min.0, 0)] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s = max(max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x), 0)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     denominator[numerator.s1.rv$x - min(next.min.0, 0)] = denominator[numerator.s1.rv$x - min(next.min.0, 0)] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
    free denominator_inter
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    for (next.s0.si.rebased, 0, next.extent.0) {
     let next.s0.si = next.s0.si.rebased + next.min.0
     next[next.s0.si - next.min.0] = numerator[next.s0.si - min(next.min.0, 0)]/denominator[next.s0.si - min(next.min.0, 0)]
    }
   }
  }
 }
 free numerator
 free denominator
}

Simplifying...
Lowering unsafe promises...
Lowering after lowering unsafe promises:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si.rebased, 0, numerator.si.extent_realized) {
    let denominator.s0.si = denominator.s0.si.rebased + min(next.min.0, 0)
    denominator[denominator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s0.si.rebased, 0, numerator.si.extent_realized) {
    let numerator.s0.si = numerator.s0.si.rebased + min(next.min.0, 0)
    numerator[numerator.s0.si - min(next.min.0, 0)] = 0
   }
   for (numerator.s1.rv$x, 0, 10) {
    let t10 = numerator.s1.rv$x - min(next.min.0, 0)
    numerator[t10] = numerator[t10] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s = max(max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x), 0)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     let t11 = numerator.s1.rv$x - min(next.min.0, 0)
     denominator[t11] = denominator[t11] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
    free denominator_inter
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    for (next.s0.si.rebased, 0, next.extent.0) {
     let next.s0.si = next.s0.si.rebased + next.min.0
     let t12 = next.s0.si - min(next.min.0, 0)
     next[next.s0.si - next.min.0] = numerator[t12]/denominator[t12]
    }
   }
  }
 }
 free numerator
 free denominator
}

Flattening nested ramps...
Lowering after flattening nested ramps: (unchanged)

Removing dead allocations and moving loop invariant code...
Lowering after removing dead allocations and hoisting loop invariants:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si.rebased, 0, numerator.si.extent_realized) {
    denominator[denominator.s0.si.rebased] = 0
   }
   for (numerator.s0.si.rebased, 0, numerator.si.extent_realized) {
    numerator[numerator.s0.si.rebased] = 0
   }
   let t13 = min(next.min.0, 0)
   for (numerator.s1.rv$x, 0, 10) {
    let t10 = numerator.s1.rv$x - t13
    numerator[t10] = numerator[t10] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s.s = max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     let t11 = numerator.s1.rv$x - t13
     denominator[t11] = denominator[t11] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
    free denominator_inter
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    let t14 = max(next.min.0, 0)
    for (next.s0.si.rebased, 0, next.extent.0) {
     let t12 = next.s0.si.rebased + t14
     next[next.s0.si.rebased] = numerator[t12]/denominator[t12]
    }
   }
  }
 }
 free numerator
 free denominator
}

Finding intrinsics...
Lowering after finding intrinsics:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si.rebased, 0, numerator.si.extent_realized) {
    denominator[denominator.s0.si.rebased] = 0
   }
   for (numerator.s0.si.rebased, 0, numerator.si.extent_realized) {
    numerator[numerator.s0.si.rebased] = 0
   }
   let t13 = min(next.min.0, 0)
   for (numerator.s1.rv$x, 0, 10) {
    let t10 = numerator.s1.rv$x - t13
    numerator[t10] = numerator[t10] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s.s = max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     let t11 = numerator.s1.rv$x - t13
     denominator[t11] = denominator[t11] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
    free denominator_inter
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    let t14 = max(next.min.0, 0)
    for (next.s0.si.rebased, 0, next.extent.0) {
     let t12 = next.s0.si.rebased + t14
     next[next.s0.si.rebased] = numerator[t12]/denominator[t12]
    }
   }
  }
 }
 free numerator
 free denominator
}

Hoisting prefetches...
Lowering after hoisting prefetches:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si.rebased, 0, numerator.si.extent_realized) {
    denominator[denominator.s0.si.rebased] = 0
   }
   for (numerator.s0.si.rebased, 0, numerator.si.extent_realized) {
    numerator[numerator.s0.si.rebased] = 0
   }
   let t13 = min(next.min.0, 0)
   for (numerator.s1.rv$x, 0, 10) {
    let t10 = numerator.s1.rv$x - t13
    numerator[t10] = numerator[t10] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s.s = max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     let t11 = numerator.s1.rv$x - t13
     denominator[t11] = denominator[t11] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
    free denominator_inter
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    let t14 = max(next.min.0, 0)
    for (next.s0.si.rebased, 0, next.extent.0) {
     let t12 = next.s0.si.rebased + t14
     next[next.s0.si.rebased] = numerator[t12]/denominator[t12]
    }
   }
  }
 }
 free numerator
 free denominator
}

Lowering after final simplification:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si.rebased, 0, numerator.si.extent_realized) {
    denominator[denominator.s0.si.rebased] = 0
   }
   for (numerator.s0.si.rebased, 0, numerator.si.extent_realized) {
    numerator[numerator.s0.si.rebased] = 0
   }
   let t13 = min(next.min.0, 0)
   for (numerator.s1.rv$x, 0, 10) {
    let t10 = numerator.s1.rv$x - t13
    numerator[t10] = numerator[t10] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s.s = max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     let t11 = numerator.s1.rv$x - t13
     denominator[t11] = denominator[t11] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
    free denominator_inter
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    let t14 = max(next.min.0, 0)
    for (next.s0.si.rebased, 0, next.extent.0) {
     let t12 = next.s0.si.rebased + t14
     next[next.s0.si.rebased] = numerator[t12]/denominator[t12]
    }
   }
  }
 }
 free numerator
 free denominator
}


Skipping Hexagon offload...
Skipping GPU offload...
Lowering Parallel Tasks...
Lowering after generating parallel tasks and closures:
assert(reinterpret<uint64>((struct halide_buffer_t *)next.buffer) != (uint64)0, halide_error_buffer_argument_is_null("next"))
let next = (void *)_halide_buffer_get_host((struct halide_buffer_t *)next.buffer)
let next.type = (uint32)_halide_buffer_get_type((struct halide_buffer_t *)next.buffer)
let next.device_dirty = (uint1)_halide_buffer_get_device_dirty((struct halide_buffer_t *)next.buffer)
let next.dimensions = _halide_buffer_get_dimensions((struct halide_buffer_t *)next.buffer)
let next.min.0 = _halide_buffer_get_min((struct halide_buffer_t *)next.buffer, 0)
let next.extent.0 = _halide_buffer_get_extent((struct halide_buffer_t *)next.buffer, 0)
let next.stride.0 = _halide_buffer_get_stride((struct halide_buffer_t *)next.buffer, 0)
if ((uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 (struct halide_buffer_t *)_halide_buffer_init((struct halide_buffer_t *)next.buffer, (struct halide_dimension_t *)_halide_buffer_get_shape((struct halide_buffer_t *)next.buffer), reinterpret<(void *)>((uint64)0), (uint64)0, reinterpret<(struct halide_device_interface_t *)>((uint64)0), 0, 32, 1, (struct halide_dimension_t *)make_struct(next.min.0, next.extent.0, 1, 0), (uint64)0)
}
if (!(uint1)_halide_buffer_is_bounds_query((struct halide_buffer_t *)next.buffer)) {
 assert(next.type == (uint32)73728, halide_error_bad_type("Output buffer next", next.type, (uint32)73728))
 assert(next.dimensions == 1, halide_error_bad_dimensions("Output buffer next", next.dimensions, 1))
 assert(0 <= next.extent.0, halide_error_buffer_extents_negative("Output buffer next", 0, next.extent.0))
 assert(next.stride.0 == 1, halide_error_constraint_violated("next.stride.0", next.stride.0, "1", 1))
 assert(uint64(next.extent.0) <= (uint64)2147483647, halide_error_buffer_allocation_too_large("next", uint64(next.extent.0), (uint64)2147483647))
 assert(!next.device_dirty, halide_error_device_dirty_with_no_device_support("Output buffer next"))
 assert(next != reinterpret<(void *)>((uint64)0), halide_error_host_is_null("Output buffer next"))
 let numerator.si.extent_realized = max(next.extent.0 + next.min.0, 10) - min(next.min.0, 0)
 allocate numerator[int32 * numerator.si.extent_realized]
 allocate denominator[int32 * 1 * numerator.si.extent_realized]
 produce denominator {
  produce numerator {
   for (denominator.s0.si.rebased, 0, numerator.si.extent_realized) {
    denominator[denominator.s0.si.rebased] = 0
   }
   for (numerator.s0.si.rebased, 0, numerator.si.extent_realized) {
    numerator[numerator.s0.si.rebased] = 0
   }
   let t13 = min(next.min.0, 0)
   for (numerator.s1.rv$x, 0, 10) {
    let t10 = numerator.s1.rv$x - t13
    numerator[t10] = numerator[t10] + numerator.s1.rv$x
    let denominator_inter.vis.min_realized = min(denominator.s1.rv$x, numerator.s1.rv$x)
    let denominator_inter.vis.extent_realized.s.s.s = max(denominator.s1.rv$x, numerator.s1.rv$x) - min(denominator.s1.rv$x, numerator.s1.rv$x)
    allocate denominator_inter[int32 * 1 * (max(denominator_inter.vis.extent_realized.s.s.s, 0) + 1)]
    produce denominator_inter {
     denominator_inter[denominator.s1.rv$x - denominator_inter.vis.min_realized] = denominator.s1.rv$x
    }
    consume denominator_inter {
     let t11 = numerator.s1.rv$x - t13
     denominator[t11] = denominator[t11] + denominator_inter[max(numerator.s1.rv$x - denominator.s1.rv$x, 0)]
    }
    free denominator_inter
   }
  }
 }
 produce next {
  consume denominator {
   consume numerator {
    let t14 = max(next.min.0, 0)
    for (next.s0.si.rebased, 0, next.extent.0) {
     let t12 = next.s0.si.rebased + t14
     next[next.s0.si.rebased] = numerator[t12]/denominator[t12]
    }
   }
  }
 }
 free numerator
 free denominator
}


Target triple of initial module: x86_64--linux-gnu
Generating llvm bitcode...
Generating llvm bitcode prolog for function Test...
Generating llvm bitcode for function Test...
Subcontext threw exception. Rethrowing...
dir_rmdir: /tmp/RrfGYC
Halide Error: Internal Error at /home/lars/data/halide-master/src/CodeGen_LLVM.cpp:1293 triggered by user code at : Symbol not found: denominator.s1.rv$x
The following names are in scope:
{
  ::Test
  denominator
  next
  next.buffer
  next.device_dirty
  next.dimensions
  next.extent.0
  next.min.0
  next.stride.0
  next.type
  numerator
  numerator.s1.rv$x
  numerator.si.extent_realized
  t13
}

terminate called after throwing an instance of 'Halide::InternalError'