#include "action.h"

using namespace roo_display;

// Image file ic_round_24_action_123 24x24, 4-bit Alpha,  RLE, 53 bytes.
static const unsigned char ic_round_24_action_123_data[] PROGMEM = {
  0x81, 0xCF, 0xB2, 0x0C, 0xB8, 0x14, 0x0C, 0xB8, 0x14, 0x5B, 0x92, 0x89, 0x35, 0x77, 0xF7, 0x05,
  0x77, 0xF7, 0x07, 0x92, 0x83, 0x47, 0x7F, 0x72, 0x84, 0x67, 0xF7, 0x07, 0x92, 0x98, 0x2B, 0x77,
  0x12, 0x84, 0x67, 0xF7, 0x07, 0x92, 0x98, 0x93, 0xB7, 0x71, 0x05, 0x77, 0xF7, 0x05, 0xC2, 0x0B,
  0xB8, 0x15, 0x0C, 0xB0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_123() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 9, 19, 14), Box(0, 0, 23, 23),
      ic_round_24_action_123_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_3d_rotation 24x24, 4-bit Alpha,  RLE, 159 bytes.
static const unsigned char ic_round_24_action_3d_rotation_data[] PROGMEM = {
  0x74, 0x84, 0x3E, 0xDB, 0x71, 0x77, 0x50, 0x30, 0xEB, 0x0A, 0x01, 0x77, 0x48, 0x53, 0xEF, 0xAF,
  0xE4, 0x77, 0x48, 0x53, 0x70, 0x2C, 0xF6, 0x77, 0x71, 0x81, 0xBF, 0x47, 0x77, 0x18, 0x1B, 0xE1,
  0x77, 0x78, 0x12, 0xF9, 0x77, 0x71, 0x81, 0x8F, 0x16, 0x83, 0x4C, 0xFB, 0x21, 0xB0, 0xC0, 0x54,
  0x81, 0x2F, 0x66, 0x89, 0x2E, 0x71, 0xAB, 0x0F, 0x72, 0x6F, 0x44, 0x0D, 0x0A, 0x60, 0x12, 0x83,
  0x7C, 0x0F, 0x62, 0x0A, 0x0B, 0x40, 0x70, 0xA7, 0x85, 0x49, 0xE4, 0x0F, 0x62, 0x07, 0x0E, 0x76,
  0x85, 0x27, 0xD7, 0x0F, 0x62, 0x07, 0x0E, 0x60, 0xA0, 0x74, 0x03, 0x28, 0x35, 0xE0, 0xF6, 0x20,
  0xA0, 0xC6, 0x0A, 0x0D, 0x48, 0x92, 0xE7, 0x19, 0xC0, 0xF7, 0x27, 0xF4, 0x68, 0x16, 0xF2, 0x38,
  0x34, 0xCF, 0xB2, 0x1B, 0x0C, 0x05, 0x78, 0x11, 0xF8, 0x77, 0x71, 0x81, 0x8F, 0x27, 0x77, 0x81,
  0x1E, 0xC7, 0x77, 0x18, 0x14, 0xFB, 0x77, 0x71, 0x85, 0x5F, 0xC2, 0x07, 0x37, 0x74, 0x85, 0x4E,
  0xFB, 0xFE, 0x37, 0x74, 0x01, 0x09, 0xB0, 0xE0, 0x37, 0x75, 0x84, 0x17, 0xBD, 0xE3, 0x74,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_3d_rotation() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 0, 23, 23), Box(0, 0, 23, 23),
      ic_round_24_action_3d_rotation_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_abc 24x24, 4-bit Alpha,  RLE, 52 bytes.
static const unsigned char ic_round_24_action_abc_data[] PROGMEM = {
  0x0B, 0xB8, 0x1B, 0x04, 0xC8, 0x14, 0x0B, 0xB8, 0xC0, 0xBF, 0xB7, 0xBF, 0x07, 0xF7, 0x7F, 0x70,
  0xFB, 0x79, 0xCF, 0x70, 0x7F, 0x07, 0xFB, 0xBF, 0x40, 0xF7, 0x3D, 0x18, 0x77, 0xFB, 0xBF, 0x40,
  0xF7, 0x39, 0x8A, 0x6B, 0x7B, 0xF0, 0x7F, 0x77, 0xF7, 0x0F, 0xB7, 0x9C, 0xC5, 0x05, 0xC0, 0x4C,
  0x81, 0x40, 0xBB, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_abc() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 9, 20, 14), Box(0, 0, 23, 23),
      ic_round_24_action_abc_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_accessibility_new 24x24, 4-bit Alpha,  RLE, 64 bytes.
static const unsigned char ic_round_24_action_accessibility_new_data[] PROGMEM = {
  0x78, 0x24, 0xDD, 0x47, 0x70, 0xDA, 0x0D, 0x77, 0x0D, 0xA0, 0xD7, 0x78, 0x24, 0xDD, 0x47, 0x86,
  0x5B, 0x96, 0x42, 0x11, 0x28, 0x71, 0x12, 0x46, 0x9B, 0x5A, 0xFF, 0xA8, 0x5A, 0x05, 0x8A, 0xCE,
  0xE8, 0x4E, 0xCA, 0x85, 0x16, 0xE7, 0x5E, 0x75, 0xE7, 0x5E, 0x75, 0xE7, 0x5E, 0x75, 0xE7, 0x5A,
  0x2A, 0x75, 0xA2, 0xA7, 0x5A, 0x2A, 0x75, 0xA2, 0xA7, 0x5A, 0x2A, 0x75, 0x00, 0xB2, 0x00, 0xB6,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_accessibility_new() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_accessibility_new_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_accessibility 24x24, 4-bit Alpha,  RLE, 51 bytes.
static const unsigned char ic_round_24_action_accessibility_data[] PROGMEM = {
  0x78, 0x24, 0xDD, 0x47, 0x70, 0xDA, 0x0D, 0x77, 0x0D, 0xA0, 0xD7, 0x78, 0x24, 0xDD, 0x47, 0x77,
  0x40, 0xBF, 0xFA, 0x00, 0xBF, 0xFA, 0x0B, 0x6E, 0x75, 0xE7, 0x5E, 0x75, 0xE7, 0x5E, 0x75, 0xE7,
  0x5E, 0x75, 0xA2, 0xA7, 0x5A, 0x2A, 0x75, 0xA2, 0xA7, 0x5A, 0x2A, 0x75, 0xA2, 0xA7, 0x50, 0x0B,
  0x20, 0x0B, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_accessibility() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_accessibility_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_accessible_forward 24x24, 4-bit Alpha,  RLE, 96 bytes.
static const unsigned char ic_round_24_action_accessible_forward_data[] PROGMEM = {
  0x75, 0x00, 0x57, 0x50, 0xAA, 0x0A, 0x74, 0x0E, 0xA0, 0xE7, 0x40, 0xAA, 0x0A, 0x75, 0x00, 0x65,
  0x07, 0x0E, 0xD0, 0xD0, 0x45, 0x03, 0xF9, 0x0D, 0x58, 0x35, 0xF8, 0x03, 0xC0, 0xD6, 0x03, 0x20,
  0xAC, 0x07, 0x71, 0x02, 0xC0, 0xE0, 0x14, 0x83, 0x4B, 0xE0, 0x8C, 0x09, 0x40, 0x8B, 0x10, 0xDC,
  0x83, 0x97, 0x60, 0x4A, 0x82, 0x71, 0x0D, 0xF8, 0x2A, 0xBF, 0x73, 0x03, 0x0D, 0xF8, 0x1E, 0xF1,
  0x73, 0xA8, 0x1E, 0xF1, 0x48, 0x11, 0xFE, 0x3A, 0x81, 0xBF, 0x74, 0x81, 0x7F, 0xB3, 0xA0, 0x4A,
  0x82, 0x71, 0x17, 0xA0, 0x43, 0xA1, 0x08, 0xE0, 0x84, 0x00, 0xB2, 0x84, 0x4B, 0xEE, 0xB4, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_accessible_forward() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_accessible_forward_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_accessible 24x24, 4-bit Alpha,  RLE, 88 bytes.
static const unsigned char ic_round_24_action_accessible_data[] PROGMEM = {
  0x58, 0x24, 0xDD, 0x47, 0x30, 0xDA, 0x0D, 0x73, 0x0D, 0xA0, 0xD7, 0x38, 0x24, 0xDD, 0x47, 0x77,
  0x38, 0x24, 0xDD, 0x57, 0x30, 0xDB, 0x05, 0x72, 0xD0, 0x57, 0x1E, 0x0A, 0x03, 0x6C, 0x05, 0x0E,
  0xA0, 0xC2, 0x04, 0x0A, 0x1C, 0x18, 0x41, 0x6B, 0xA0, 0x7A, 0x1C, 0x50, 0x3A, 0x07, 0x1C, 0x0F,
  0x78, 0x36, 0x0B, 0xF7, 0x20, 0xDF, 0x82, 0xAE, 0xF1, 0x20, 0x40, 0xDF, 0x81, 0xEF, 0x17, 0x2A,
  0x81, 0xBF, 0x74, 0x81, 0x6F, 0xA2, 0xA0, 0x4A, 0x82, 0x71, 0x17, 0xA0, 0x42, 0xA1, 0x08, 0xE0,
  0x73, 0xA2, 0x84, 0x4B, 0xEE, 0xB3, 0x40, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_accessible() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 2, 18, 21), Box(0, 0, 23, 23),
      ic_round_24_action_accessible_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_account_balance 24x24, 4-bit Alpha,  RLE, 81 bytes.
static const unsigned char ic_round_24_action_account_balance_data[] PROGMEM = {
  0x71, 0x81, 0x6A, 0x67, 0x70, 0x60, 0xEB, 0x0E, 0x06, 0x73, 0x05, 0x0D, 0xF0, 0xD0, 0x56, 0x04,
  0x0C, 0xFC, 0x0C, 0x04, 0x20, 0x30, 0xCF, 0xF9, 0x81, 0xC3, 0xEF, 0xFB, 0x0E, 0x09, 0xFF, 0xB0,
  0x98, 0x0C, 0x40, 0x81, 0x8E, 0x83, 0x81, 0x8E, 0x83, 0x81, 0x8E, 0x84, 0xB3, 0xB3, 0xB4, 0xB3,
  0xB3, 0xB4, 0xB3, 0xB3, 0xB4, 0xB3, 0xB3, 0xB4, 0xB3, 0xB3, 0xB4, 0x81, 0x8E, 0x83, 0x81, 0x8E,
  0x83, 0x81, 0x8E, 0x88, 0x0C, 0x40, 0x08, 0xFF, 0xB0, 0x80, 0xEF, 0xFB, 0x0E, 0x08, 0xFF, 0xB0,
  0x80,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_account_balance() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 1, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_account_balance_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_account_balance_wallet 24x24, 4-bit Alpha,  RLE, 60 bytes.
static const unsigned char ic_round_24_action_account_balance_wallet_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x82, 0xD4, 0x0D, 0xFF, 0xA0, 0xD1, 0xFF, 0xC1, 0xF0, 0xB0, 0x17, 0x3F, 0x01,
  0x74, 0xF2, 0x0B, 0xFF, 0xA2, 0xFF, 0xB2, 0xB0, 0x09, 0xFD, 0x2A, 0x09, 0x20, 0x9F, 0xC2, 0xA0,
  0x92, 0x09, 0xFC, 0x2B, 0x00, 0x9F, 0xD2, 0xFF, 0xB2, 0x0B, 0xFF, 0xA0, 0x17, 0x4F, 0x0B, 0x01,
  0x73, 0xFF, 0xC1, 0x0D, 0xFF, 0xA8, 0x2D, 0x04, 0xDF, 0xF0, 0xD0, 0x41,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_account_balance_wallet() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_account_balance_wallet_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_account_box 24x24, 4-bit Alpha,  RLE, 66 bytes.
static const unsigned char ic_round_24_action_account_box_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0xFF, 0xFB, 0x84, 0xE6, 0x11, 0x6E, 0xFD, 0x03,
  0x40, 0x3F, 0xC0, 0xA6, 0x0A, 0xFB, 0x08, 0x60, 0x8F, 0xB0, 0xA6, 0x0A, 0xFC, 0x03, 0x40, 0x3F,
  0xD8, 0x4E, 0x61, 0x16, 0xE8, 0x0D, 0x3F, 0x81, 0xA5, 0x22, 0x81, 0x25, 0xAF, 0x90, 0xA0, 0x17,
  0x10, 0x10, 0xAD, 0x08, 0x75, 0x08, 0xC0, 0x17, 0x50, 0x1A, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF,
  0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_account_box() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_account_box_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_account_circle 24x24, 4-bit Alpha,  RLE, 119 bytes.
static const unsigned char ic_round_24_action_account_circle_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xD8, 0x4E, 0x61, 0x16, 0xED, 0x04, 0x20, 0xDD, 0x03, 0x40, 0x3D, 0x81,
  0xD0, 0x5D, 0x0A, 0x60, 0xAD, 0x05, 0x09, 0xD0, 0x86, 0x08, 0xD0, 0x90, 0xDD, 0x0A, 0x60, 0xAD,
  0x0D, 0x0E, 0xE0, 0x34, 0x03, 0xE0, 0x0E, 0xE8, 0x4E, 0x61, 0x16, 0xEE, 0x0E, 0x0D, 0xFF, 0xC0,
  0xD0, 0x9F, 0xFC, 0x09, 0x05, 0xD8, 0x1A, 0x52, 0x28, 0x12, 0x5A, 0xD8, 0x15, 0x0D, 0xA0, 0xA0,
  0x17, 0x10, 0x10, 0xAA, 0x0D, 0x20, 0x4A, 0x04, 0x73, 0x04, 0xA0, 0x43, 0x08, 0xA0, 0x67, 0x10,
  0x6A, 0x08, 0x50, 0x8A, 0x81, 0xC7, 0x22, 0x81, 0x27, 0xCA, 0x08, 0x70, 0x40, 0xDF, 0x90, 0xD0,
  0x47, 0x38, 0x65, 0x9D, 0xEE, 0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_account_circle() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_account_circle_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_add_card 24x24, 4-bit Alpha,  RLE, 58 bytes.
static const unsigned char ic_round_24_action_add_card_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA0, 0xD0, 0x42, 0x0D, 0xFF, 0xC0, 0xD2, 0xA7, 0x72, 0xA2, 0xA7, 0x72, 0xA2,
  0xFF, 0xE2, 0xFF, 0xE2, 0xFF, 0xE2, 0xFF, 0xE2, 0xA7, 0x76, 0xA7, 0x76, 0xA7, 0x71, 0x00, 0xB3,
  0xA7, 0x71, 0xA3, 0xA7, 0x71, 0xA3, 0xA7, 0x50, 0xBE, 0x0B, 0x0D, 0xFB, 0x0B, 0x20, 0xBE, 0x81,
  0xB4, 0xDF, 0xA0, 0xB5, 0xA7, 0x76, 0xA7, 0x76, 0x00, 0xB3,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_add_card() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 23, 21), Box(0, 0, 23, 23),
      ic_round_24_action_add_card_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_addchart 24x24, 4-bit Alpha,  RLE, 77 bytes.
static const unsigned char ic_round_24_action_addchart_data[] PROGMEM = {
  0x77, 0x00, 0xB3, 0x04, 0x0D, 0xD0, 0xB6, 0xA3, 0x0D, 0xE0, 0xB6, 0xA3, 0xA7, 0x20, 0xBE, 0x0B,
  0xA7, 0x20, 0xBE, 0x0B, 0xA7, 0x5A, 0x3A, 0x75, 0xA3, 0xA6, 0x00, 0xB4, 0x00, 0xB3, 0xA6, 0xA7,
  0x2A, 0x20, 0x0B, 0x2A, 0x72, 0xA2, 0xA2, 0xA7, 0x2A, 0x2A, 0x2A, 0x20, 0x0B, 0x20, 0x0B, 0x1A,
  0x2A, 0x2A, 0x2A, 0x2A, 0x1A, 0x2A, 0x2A, 0x2A, 0x2A, 0x1A, 0x2A, 0x2A, 0x2A, 0x2A, 0x1A, 0x77,
  0xA1, 0xA7, 0x7A, 0x10, 0xDF, 0xFA, 0x82, 0xD0, 0x4D, 0xFF, 0x0D, 0x04, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_addchart() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_addchart_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_add_home 24x24, 4-bit Alpha,  RLE, 109 bytes.
static const unsigned char ic_round_24_action_add_home_data[] PROGMEM = {
  0x70, 0x06, 0x77, 0x10, 0x20, 0xCA, 0x0C, 0x02, 0x75, 0x05, 0x0E, 0xC0, 0xE0, 0x57, 0x30, 0x9F,
  0x90, 0x97, 0x02, 0x0C, 0xFB, 0x0C, 0x02, 0x40, 0x40, 0xEF, 0xD0, 0xE0, 0x43, 0x0D, 0xFF, 0x0D,
  0x3F, 0xFA, 0x3F, 0xB8, 0x4E, 0x83, 0x10, 0x33, 0xFA, 0x0B, 0x01, 0x71, 0xF9, 0x0B, 0x28, 0x44,
  0xBE, 0xEB, 0x42, 0xF8, 0x2E, 0x10, 0x8E, 0x08, 0x1F, 0x81, 0x80, 0x4B, 0x00, 0x7B, 0x04, 0xF8,
  0x13, 0x0B, 0xB0, 0x07, 0xB0, 0xBF, 0x28, 0x90, 0xEF, 0x77, 0x33, 0x77, 0xFE, 0xF2, 0x89, 0x1E,
  0xF7, 0x73, 0x37, 0x7F, 0xED, 0xE8, 0x12, 0x0B, 0xB0, 0x07, 0xB8, 0x1B, 0x4D, 0xD8, 0x17, 0x04,
  0xB0, 0x07, 0xB0, 0x47, 0x30, 0x8E, 0x08, 0x75, 0x84, 0x4B, 0xEE, 0xB4, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_add_home() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 3, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_add_home_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_add_shopping_cart 24x24, 4-bit Alpha,  RLE, 117 bytes.
static const unsigned char ic_round_24_action_add_shopping_cart_data[] PROGMEM = {
  0x73, 0x00, 0xB7, 0x10, 0xBA, 0x07, 0x6A, 0x71, 0x0B, 0xA0, 0xE6, 0xA7, 0x38, 0x1B, 0xF7, 0x20,
  0xBE, 0x0B, 0x30, 0x70, 0x22, 0x81, 0x4F, 0xD2, 0x0B, 0xE0, 0xB2, 0x81, 0x8F, 0x83, 0x81, 0xCF,
  0x64, 0xA4, 0x82, 0x1E, 0xF3, 0x38, 0x15, 0xFD, 0x4A, 0x48, 0x19, 0xFA, 0x58, 0x1D, 0xF5, 0x30,
  0x0B, 0x30, 0x2A, 0x02, 0x58, 0x16, 0xFC, 0x71, 0x81, 0xAF, 0x97, 0x81, 0xDF, 0x46, 0x82, 0x3F,
  0xE1, 0x70, 0x8F, 0xB0, 0x87, 0x10, 0xDF, 0xA0, 0xA7, 0x18, 0x17, 0xFC, 0x77, 0x38, 0x1D, 0xF4,
  0x77, 0x30, 0xDF, 0xD0, 0xB6, 0x04, 0x0D, 0xFC, 0x0B, 0x77, 0x75, 0x82, 0x4D, 0xD4, 0x68, 0x24,
  0xDD, 0x46, 0x0D, 0xA0, 0xD6, 0x0D, 0xA0, 0xD6, 0x0D, 0xA0, 0xD6, 0x0D, 0xA0, 0xD6, 0x82, 0x4D,
  0xD4, 0x68, 0x24, 0xDD, 0x42,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_add_shopping_cart() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_add_shopping_cart_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_add_task 24x24, 4-bit Alpha,  RLE, 144 bytes.
static const unsigned char ic_round_24_action_add_task_data[] PROGMEM = {
  0x68, 0x15, 0xAD, 0xA8, 0x1D, 0xA5, 0x75, 0x04, 0x0D, 0xF9, 0x0D, 0x73, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x22, 0x6C, 0xD2, 0x81, 0x3A, 0x34, 0x08, 0xA0, 0x67, 0x38, 0x23, 0xEF, 0x63, 0x04, 0xA0,
  0x47, 0x38, 0x23, 0xEF, 0xA4, 0x81, 0xDF, 0x67, 0x38, 0x23, 0xEF, 0xA4, 0x81, 0x5F, 0xC7, 0x38,
  0x23, 0xEF, 0xA5, 0x81, 0xAF, 0x67, 0x28, 0x23, 0xEF, 0xA6, 0x81, 0xDF, 0x27, 0x18, 0x23, 0xEF,
  0xA7, 0x0E, 0x93, 0x07, 0x04, 0x38, 0x23, 0xEF, 0xA7, 0x10, 0xE9, 0x20, 0x2A, 0x84, 0x50, 0x3E,
  0xFA, 0x40, 0x0B, 0x38, 0x1D, 0xF2, 0x20, 0x7A, 0x82, 0x7E, 0xFA, 0x5A, 0x38, 0x19, 0xF6, 0x30,
  0x7B, 0x0A, 0x6A, 0x38, 0x15, 0xFD, 0x48, 0x17, 0xFA, 0x40, 0xBE, 0x83, 0xB0, 0xDF, 0x64, 0x01,
  0x50, 0xBE, 0x81, 0xB0, 0x4A, 0x04, 0x75, 0xA5, 0x08, 0xA0, 0x67, 0x4A, 0x60, 0x8A, 0x81, 0xC6,
  0x22, 0x81, 0x26, 0x53, 0x00, 0xB7, 0x04, 0x0D, 0xF9, 0x77, 0x86, 0x59, 0xDE, 0xED, 0x94, 0x71,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_add_task() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 23, 21), Box(0, 0, 23, 23),
      ic_round_24_action_add_task_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_add_to_drive 24x24, 4-bit Alpha,  RLE, 109 bytes.
static const unsigned char ic_round_24_action_add_to_drive_data[] PROGMEM = {
  0x70, 0xBD, 0x04, 0x76, 0x01, 0x02, 0xD0, 0xC7, 0x58, 0x26, 0xB0, 0x8D, 0x06, 0x74, 0x83, 0xEF,
  0x41, 0xEC, 0x0E, 0x73, 0x08, 0xA8, 0x1D, 0x06, 0xD0, 0x87, 0x10, 0x10, 0xEB, 0x81, 0x60, 0xCC,
  0x0E, 0x01, 0x70, 0x9C, 0x81, 0xE1, 0x3D, 0x09, 0x60, 0x3D, 0x82, 0xE1, 0x0A, 0xD0, 0x35, 0x0B,
  0xD0, 0x72, 0x83, 0x1E, 0xF8, 0x36, 0x04, 0xD0, 0xD4, 0x06, 0x02, 0x71, 0x0D, 0xD0, 0x57, 0x1A,
  0x30, 0x6D, 0x0B, 0x72, 0xA3, 0x0D, 0xD8, 0x42, 0x17, 0x77, 0x14, 0xA3, 0x07, 0xC8, 0x19, 0x0A,
  0xB0, 0x11, 0xF9, 0x10, 0xDA, 0x81, 0xE1, 0x3C, 0x2F, 0x91, 0x05, 0xA8, 0x16, 0x0C, 0xC0, 0x34,
  0xA5, 0x82, 0xCD, 0x06, 0xD0, 0x84, 0xA5, 0x82, 0x44, 0x1E, 0xE0, 0x33, 0xA3,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_add_to_drive() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_add_to_drive_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_admin_panel_settings 24x24, 4-bit Alpha,  RLE, 99 bytes.
static const unsigned char ic_round_24_action_admin_panel_settings_data[] PROGMEM = {
  0x58, 0x32, 0x8B, 0x82, 0x74, 0x03, 0x0A, 0xD0, 0xA0, 0x37, 0x05, 0x0C, 0xFA, 0x0C, 0x05, 0x40,
  0x9F, 0xE0, 0x93, 0xFF, 0x93, 0xFF, 0x93, 0xFF, 0x93, 0xFF, 0x93, 0xFC, 0x08, 0x03, 0x50, 0xDF,
  0x90, 0xD0, 0x27, 0x0A, 0xF9, 0x89, 0x02, 0x01, 0xAD, 0xDA, 0x10, 0x6F, 0x89, 0x28, 0x01, 0xEF,
  0x88, 0xFE, 0x10, 0xEE, 0x83, 0x30, 0xAF, 0xE2, 0x83, 0xEF, 0xA0, 0x6E, 0x20, 0xDA, 0x00, 0x8A,
  0x0D, 0x20, 0xBD, 0x89, 0x01, 0x0D, 0xFD, 0x88, 0xDF, 0xD2, 0x01, 0x0C, 0xC8, 0x23, 0x0A, 0xE4,
  0x0E, 0x0A, 0x40, 0x9B, 0x89, 0x09, 0x01, 0xEB, 0x44, 0xBE, 0x15, 0x82, 0x3A, 0xE9, 0x28, 0x41,
  0xAD, 0xDA, 0x11,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_admin_panel_settings() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_admin_panel_settings_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_ads_click 24x24, 4-bit Alpha,  RLE, 182 bytes.
static const unsigned char ic_round_24_action_ads_click_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x40, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x10, 0x8A, 0x81, 0xC6,
  0x22, 0x81, 0x26, 0xCA, 0x08, 0x60, 0x8A, 0x06, 0x71, 0x06, 0xA0, 0x84, 0x04, 0xA0, 0x42, 0x84,
  0x6C, 0xEE, 0xC6, 0x20, 0x4A, 0x04, 0x38, 0x4D, 0xF6, 0x01, 0xCE, 0x84, 0xC1, 0x06, 0xFD, 0x28,
  0x15, 0xFC, 0x28, 0x90, 0xCF, 0xD5, 0x11, 0x5D, 0xFC, 0x28, 0x92, 0xCF, 0x50, 0x9F, 0x60, 0x6F,
  0xD1, 0x48, 0x96, 0x1D, 0xF6, 0x06, 0xF9, 0x0D, 0xF2, 0x0C, 0xF5, 0x68, 0x75, 0xFC, 0x02, 0xFD,
  0x0E, 0x92, 0x81, 0xEF, 0x17, 0x04, 0x08, 0x29, 0x81, 0xE0, 0xE9, 0x28, 0x1E, 0xF1, 0x38, 0x17,
  0x83, 0x58, 0x90, 0x7B, 0x0D, 0xF2, 0x0C, 0xF5, 0x30, 0x8A, 0x81, 0xE9, 0x55, 0x86, 0x9F, 0x60,
  0x6F, 0xD1, 0x20, 0x3E, 0x0B, 0x05, 0x28, 0x15, 0xFC, 0x28, 0x2C, 0xFD, 0x52, 0x0E, 0xD0, 0xC0,
  0x63, 0x84, 0xDF, 0x60, 0x1C, 0xA8, 0x14, 0x0A, 0xC0, 0x95, 0x04, 0xA0, 0x42, 0x83, 0x6C, 0x80,
  0x5D, 0x07, 0x50, 0x8A, 0x06, 0x50, 0x1A, 0x09, 0xB0, 0x75, 0x08, 0xA8, 0x1C, 0x62, 0x38, 0x2B,
  0xC0, 0x7B, 0x07, 0x50, 0x40, 0xDC, 0x82, 0x70, 0x56, 0x20, 0x7B, 0x02, 0x68, 0x35, 0x9D, 0xEB,
  0x68, 0x17, 0xF8, 0x77, 0x50, 0x22,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_ads_click() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_ads_click_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_alarm_add 24x24, 4-bit Alpha,  RLE, 152 bytes.
static const unsigned char ic_round_24_action_alarm_add_data[] PROGMEM = {
  0x38, 0x13, 0xA2, 0x71, 0x81, 0x2A, 0x35, 0x05, 0xA0, 0x67, 0x10, 0x6A, 0x05, 0x30, 0x8A, 0x89,
  0x28, 0x04, 0x9D, 0xEE, 0xD9, 0x40, 0x8A, 0x81, 0x80, 0x6A, 0x81, 0x52, 0xBF, 0x98, 0x1B, 0x26,
  0xA8, 0x90, 0x62, 0xA3, 0x3E, 0xFE, 0x72, 0x28, 0x72, 0x7E, 0xFE, 0x33, 0xA2, 0x28, 0x22, 0xEF,
  0xA7, 0x18, 0x2A, 0xFE, 0x24, 0x81, 0xBF, 0xA7, 0x38, 0x1A, 0xFB, 0x38, 0x14, 0xFE, 0x50, 0x0B,
  0x58, 0x1E, 0xF4, 0x28, 0x19, 0xF7, 0x5A, 0x58, 0x17, 0xF9, 0x28, 0x1D, 0xF2, 0x5A, 0x58, 0x12,
  0xFD, 0x20, 0xE9, 0x30, 0xBE, 0x0B, 0x39, 0x0E, 0x20, 0xE9, 0x30, 0xBE, 0x0B, 0x39, 0x0E, 0x28,
  0x1D, 0xF2, 0x5A, 0x58, 0x12, 0xFD, 0x28, 0x19, 0xF7, 0x5A, 0x58, 0x17, 0xF9, 0x28, 0x14, 0xFE,
  0x50, 0x0B, 0x58, 0x1E, 0xF4, 0x38, 0x1B, 0xFA, 0x73, 0x81, 0xAF, 0xB4, 0x82, 0x2E, 0xFA, 0x71,
  0x82, 0xAF, 0xE2, 0x58, 0x43, 0xEF, 0xE7, 0x22, 0x84, 0x27, 0xEF, 0xE3, 0x70, 0x20, 0xBF, 0x90,
  0xB0, 0x27, 0x38, 0x64, 0x9D, 0xEE, 0xD9, 0x46,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_alarm_add() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_alarm_add_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_alarm_off 24x24, 4-bit Alpha,  RLE, 169 bytes.
static const unsigned char ic_round_24_action_alarm_off_data[] PROGMEM = {
  0x03, 0x04, 0x20, 0x60, 0x37, 0x18, 0x12, 0xA3, 0x38, 0x1D, 0xF6, 0x20, 0x37, 0x10, 0x6A, 0x06,
  0x20, 0x6A, 0x06, 0x28, 0x90, 0x29, 0xDE, 0xED, 0x94, 0x08, 0xA8, 0x18, 0x06, 0xB0, 0x62, 0x0B,
  0xE8, 0x1B, 0x25, 0xA8, 0x26, 0x2A, 0x8A, 0x06, 0x28, 0x92, 0x31, 0x02, 0x7E, 0xFE, 0x33, 0xA2,
  0x20, 0x20, 0xEA, 0x06, 0x78, 0x2A, 0xFE, 0x24, 0x81, 0xBF, 0xCA, 0x06, 0x78, 0x1A, 0xFB, 0x38,
  0x34, 0xFE, 0x06, 0xA0, 0x67, 0x81, 0xEF, 0x42, 0x81, 0x9F, 0x72, 0x06, 0xA0, 0x66, 0x81, 0x7F,
  0x92, 0x81, 0xDF, 0x23, 0x06, 0xA0, 0x65, 0x81, 0x2F, 0xD2, 0x0E, 0x95, 0x06, 0xA0, 0x65, 0x90,
  0xE2, 0x0E, 0x96, 0x06, 0xA0, 0x63, 0x81, 0x1F, 0xE2, 0x81, 0xDF, 0x26, 0x06, 0xA0, 0x62, 0x81,
  0x3F, 0xD2, 0x81, 0x9F, 0x77, 0x06, 0xA0, 0x62, 0x0B, 0x09, 0x28, 0x14, 0xFE, 0x71, 0x06, 0xA0,
  0x62, 0x02, 0x38, 0x1B, 0xFA, 0x71, 0x06, 0xA0, 0x65, 0x82, 0x2E, 0xFA, 0x71, 0x0C, 0xA0, 0x65,
  0x84, 0x3E, 0xFE, 0x72, 0x28, 0x32, 0x7E, 0xFE, 0xA0, 0x65, 0x02, 0x0B, 0xF9, 0x83, 0xB2, 0x6F,
  0xD7, 0x86, 0x49, 0xDE, 0xED, 0x94, 0x30, 0x40, 0x31,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_alarm_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_alarm_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_alarm_on 24x24, 4-bit Alpha,  RLE, 162 bytes.
static const unsigned char ic_round_24_action_alarm_on_data[] PROGMEM = {
  0x38, 0x13, 0xA2, 0x71, 0x81, 0x2A, 0x35, 0x05, 0xA0, 0x67, 0x10, 0x6A, 0x05, 0x30, 0x8A, 0x89,
  0x28, 0x04, 0x9D, 0xEE, 0xD9, 0x40, 0x8A, 0x81, 0x80, 0x6A, 0x81, 0x52, 0xBF, 0x98, 0x1B, 0x26,
  0xA8, 0x90, 0x62, 0xA3, 0x3E, 0xFE, 0x72, 0x28, 0x72, 0x7E, 0xFE, 0x33, 0xA2, 0x28, 0x22, 0xEF,
  0xA7, 0x18, 0x2A, 0xFE, 0x24, 0x81, 0xBF, 0xA7, 0x38, 0x1A, 0xFB, 0x38, 0x14, 0xFE, 0x75, 0x81,
  0xEF, 0x42, 0x81, 0x9F, 0x77, 0x18, 0x56, 0xF1, 0x07, 0xF9, 0x28, 0x1D, 0xF2, 0x78, 0x16, 0xFA,
  0x28, 0x12, 0xFD, 0x20, 0xE9, 0x30, 0x23, 0x81, 0x6F, 0xA4, 0x90, 0xE2, 0x0E, 0x92, 0x85, 0x3F,
  0x70, 0x6F, 0xA5, 0x90, 0xE2, 0x81, 0xDF, 0x22, 0x83, 0x9F, 0xBF, 0xA5, 0x81, 0x2F, 0xD2, 0x81,
  0x9F, 0x73, 0x81, 0x9F, 0xA6, 0x81, 0x7F, 0x92, 0x81, 0x4F, 0xE4, 0x03, 0x78, 0x1E, 0xF4, 0x38,
  0x1B, 0xFA, 0x73, 0x81, 0xAF, 0xB4, 0x82, 0x2E, 0xFA, 0x71, 0x82, 0xAF, 0xE2, 0x58, 0x43, 0xEF,
  0xE7, 0x22, 0x84, 0x27, 0xEF, 0xE3, 0x70, 0x20, 0xBF, 0x90, 0xB0, 0x27, 0x38, 0x64, 0x9D, 0xEE,
  0xD9, 0x46,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_alarm_on() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_alarm_on_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_alarm 24x24, 4-bit Alpha,  RLE, 160 bytes.
static const unsigned char ic_round_24_action_alarm_data[] PROGMEM = {
  0x38, 0x13, 0xA2, 0x71, 0x81, 0x2A, 0x35, 0x05, 0xA0, 0x67, 0x10, 0x6A, 0x05, 0x30, 0x8A, 0x89,
  0x28, 0x04, 0x9D, 0xEE, 0xD9, 0x40, 0x8A, 0x81, 0x80, 0x6A, 0x81, 0x52, 0xBF, 0x98, 0x1B, 0x26,
  0xA8, 0x90, 0x62, 0xA3, 0x3E, 0xFE, 0x72, 0x28, 0x72, 0x7E, 0xFE, 0x33, 0xA2, 0x28, 0x22, 0xEF,
  0xA7, 0x18, 0x2A, 0xFE, 0x24, 0x81, 0xBF, 0xA4, 0x0D, 0x05, 0x48, 0x1A, 0xFB, 0x38, 0x14, 0xFE,
  0x59, 0x07, 0x58, 0x1E, 0xF4, 0x28, 0x19, 0xF7, 0x59, 0x07, 0x58, 0x17, 0xF9, 0x28, 0x1D, 0xF2,
  0x59, 0x07, 0x58, 0x12, 0xFD, 0x20, 0xE9, 0x69, 0x07, 0x69, 0x0E, 0x20, 0xE9, 0x68, 0x1E, 0xC2,
  0x59, 0x0E, 0x28, 0x1D, 0xF2, 0x58, 0x24, 0xDF, 0x83, 0x81, 0x2F, 0xD2, 0x81, 0x9F, 0x77, 0x86,
  0x7F, 0xD1, 0x07, 0xF9, 0x28, 0x14, 0xFE, 0x71, 0x02, 0x07, 0x28, 0x1E, 0xF4, 0x38, 0x1B, 0xFA,
  0x73, 0x81, 0xAF, 0xB4, 0x82, 0x2E, 0xFA, 0x71, 0x82, 0xAF, 0xE2, 0x58, 0x43, 0xEF, 0xE7, 0x22,
  0x84, 0x27, 0xEF, 0xE3, 0x70, 0x20, 0xBF, 0x90, 0xB0, 0x27, 0x38, 0x64, 0x9D, 0xEE, 0xD9, 0x46,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_alarm() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_alarm_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_all_inbox 24x24, 4-bit Alpha,  RLE, 59 bytes.
static const unsigned char ic_round_24_action_all_inbox_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0xA0, 0x37, 0x50, 0x3C, 0x77, 0xC7, 0x7C, 0x77,
  0xF0, 0xC6, 0x0C, 0xFC, 0x07, 0x40, 0x7F, 0xE8, 0x27, 0x11, 0x7F, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D,
  0xFF, 0x0D, 0x04, 0x80, 0xC0, 0x00, 0xBC, 0x0C, 0x60, 0xCC, 0x0B, 0xE0, 0x74, 0x07, 0xFE, 0x82,
  0x71, 0x17, 0xF0, 0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xF0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_all_inbox() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_all_inbox_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_all_out 24x24, 4-bit Alpha,  RLE, 110 bytes.
static const unsigned char ic_round_24_action_all_out_data[] PROGMEM = {
  0x0E, 0xA0, 0x77, 0x10, 0x7A, 0x0E, 0xA8, 0x92, 0x70, 0x17, 0xCE, 0xEC, 0x71, 0x07, 0xB8, 0x27,
  0x05, 0xEE, 0x86, 0xE5, 0x07, 0xF7, 0x05, 0xA0, 0xA0, 0x32, 0x03, 0x0A, 0xA8, 0x65, 0x07, 0x01,
  0xEF, 0x76, 0x82, 0x7F, 0xE1, 0x28, 0x17, 0xFA, 0x71, 0x81, 0xAF, 0x72, 0x81, 0xCF, 0x37, 0x18,
  0x13, 0xFC, 0x20, 0xE9, 0x73, 0x90, 0xE2, 0x0E, 0x97, 0x39, 0x0E, 0x28, 0x1C, 0xF3, 0x71, 0x81,
  0x3F, 0xC2, 0x81, 0x7F, 0xA7, 0x18, 0x1A, 0xF7, 0x28, 0x21, 0xEF, 0x76, 0x86, 0x7F, 0xE1, 0x07,
  0x05, 0xA0, 0xA0, 0x32, 0x03, 0x0A, 0xA8, 0x65, 0x07, 0xF7, 0x05, 0xEE, 0x82, 0xE5, 0x07, 0xB8,
  0x92, 0x70, 0x17, 0xCE, 0xEC, 0x71, 0x07, 0xA0, 0xEA, 0x07, 0x71, 0x07, 0xA0, 0xE0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_all_out() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 4, 19, 19), Box(0, 0, 23, 23),
      ic_round_24_action_all_out_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_analytics 24x24, 4-bit Alpha,  RLE, 54 bytes.
static const unsigned char ic_round_24_action_analytics_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xD4, 0xF0, 0x03, 0xFF, 0xA2, 0xFF, 0xA2,
  0xFD, 0x00, 0x3A, 0x2F, 0xD0, 0x03, 0xA2, 0xF9, 0x00, 0x3E, 0x2F, 0x92, 0xE2, 0xF9, 0x2A, 0x00,
  0x3A, 0x2F, 0x92, 0xA2, 0xA2, 0xF9, 0x00, 0x3A, 0x00, 0x3A, 0x00, 0x38, 0x0C, 0x4F, 0x0D, 0xFF,
  0xA8, 0x1D, 0x4D, 0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_analytics() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_analytics_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_anchor 24x24, 4-bit Alpha,  RLE, 98 bytes.
static const unsigned char ic_round_24_action_anchor_data[] PROGMEM = {
  0x78, 0x28, 0xDD, 0x87, 0x60, 0x8C, 0x08, 0x75, 0x84, 0xDF, 0x33, 0xFD, 0x75, 0x84, 0xEF, 0x33,
  0xFE, 0x75, 0x08, 0xC0, 0x87, 0x60, 0x8A, 0x08, 0x77, 0x1A, 0x76, 0x0B, 0xE0, 0xB7, 0x30, 0xBE,
  0x0B, 0x76, 0xA7, 0x10, 0x57, 0xA7, 0x82, 0x5F, 0xC2, 0x5A, 0x50, 0x20, 0xCB, 0x0E, 0x05, 0x4A,
  0x40, 0x50, 0xEA, 0x0E, 0xA0, 0x64, 0xA4, 0x06, 0xA8, 0x2E, 0xBF, 0xA5, 0xA5, 0x82, 0xAF, 0xB4,
  0xA0, 0x34, 0xA4, 0x04, 0xA8, 0x14, 0x08, 0xA0, 0x63, 0xA3, 0x07, 0xA0, 0x83, 0x08, 0xA8, 0x1D,
  0x73, 0xA8, 0x13, 0x7D, 0xA0, 0x85, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x71, 0x86, 0x49, 0xDE, 0xED,
  0x94, 0x50,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_anchor() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_anchor_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_android 24x24, 4-bit Alpha,  RLE, 82 bytes.
static const unsigned char ic_round_24_action_android_data[] PROGMEM = {
  0x30, 0x30, 0x57, 0x50, 0x50, 0x36, 0x81, 0x4F, 0x27, 0x38, 0x12, 0xF4, 0x70, 0x0B, 0x73, 0x00,
  0xB7, 0x18, 0x94, 0x2F, 0x55, 0xAD, 0xEE, 0xDA, 0x55, 0xF2, 0x72, 0x0C, 0xFB, 0x0C, 0x71, 0x02,
  0x0C, 0xFD, 0x0C, 0x02, 0x50, 0x20, 0xEF, 0xF0, 0xE0, 0x24, 0x0C, 0xA0, 0x0D, 0xF9, 0x00, 0xDA,
  0x0C, 0x30, 0x8A, 0x0D, 0x20, 0xDE, 0x0D, 0x20, 0xDA, 0x82, 0x80, 0x1E, 0xA0, 0xD2, 0x0D, 0xE0,
  0xD2, 0x0D, 0xA8, 0x1E, 0x17, 0xC0, 0x0D, 0xF9, 0x00, 0xDC, 0x07, 0x0A, 0xFF, 0xE0, 0xA0, 0xDF,
  0xFE, 0x0D,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_android() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 5, 22, 17), Box(0, 0, 23, 23),
      ic_round_24_action_android_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_announcement 24x24, 4-bit Alpha,  RLE, 47 bytes.
static const unsigned char ic_round_24_action_announcement_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDF, 0xFF, 0xF9, 0x00, 0x3F, 0xFC, 0x2F, 0xFC,
  0x2F, 0xFC, 0x2F, 0xFC, 0x2F, 0xFC, 0x00, 0x38, 0x0E, 0x6F, 0x2F, 0xFC, 0x28, 0x0D, 0x4F, 0x0D,
  0xFF, 0xC0, 0xD0, 0x4B, 0x07, 0x77, 0x2A, 0x07, 0x77, 0x39, 0x07, 0x77, 0x40, 0x77, 0x75,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_announcement() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_announcement_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_api 24x24, 4-bit Alpha,  RLE, 125 bytes.
static const unsigned char ic_round_24_action_api_data[] PROGMEM = {
  0x73, 0x00, 0x17, 0x75, 0x07, 0xA0, 0x77, 0x73, 0x07, 0xC0, 0x77, 0x71, 0x07, 0xE0, 0x77, 0x60,
  0x5F, 0x90, 0x57, 0x60, 0xAA, 0x00, 0x7A, 0x0B, 0x74, 0x05, 0x30, 0xA0, 0x72, 0x07, 0x0B, 0x30,
  0x57, 0x81, 0x7F, 0xB7, 0x38, 0x1A, 0xF7, 0x50, 0x7B, 0x0B, 0x71, 0x0A, 0xB0, 0x73, 0x07, 0xC0,
  0x73, 0x00, 0x43, 0x07, 0xC8, 0x17, 0x01, 0xC0, 0x73, 0x04, 0xA0, 0x43, 0x07, 0xC0, 0x01, 0xC0,
  0x73, 0x04, 0xA0, 0x43, 0x07, 0xC8, 0x11, 0x07, 0xC0, 0x73, 0x00, 0x43, 0x07, 0xC0, 0x73, 0x07,
  0xB0, 0xA7, 0x10, 0xBB, 0x07, 0x58, 0x17, 0xFA, 0x73, 0x81, 0xBF, 0x77, 0x05, 0x30, 0xB0, 0x72,
  0x07, 0x0A, 0x30, 0x57, 0x40, 0xBA, 0x00, 0x7A, 0x0A, 0x76, 0x05, 0xF9, 0x05, 0x76, 0x07, 0xE0,
  0x77, 0x71, 0x07, 0xC0, 0x77, 0x73, 0x07, 0xA0, 0x77, 0x75, 0x00, 0x17, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_api() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_api_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_app_blocking 24x24, 4-bit Alpha,  RLE, 84 bytes.
static const unsigned char ic_round_24_action_app_blocking_data[] PROGMEM = {
  0x04, 0x0D, 0xFB, 0x0D, 0x04, 0x30, 0xDF, 0xD0, 0xD3, 0xFF, 0x3F, 0xF3, 0xFF, 0x3A, 0x73, 0xA3,
  0xA7, 0x71, 0xA7, 0x18, 0x41, 0xAD, 0xDA, 0x11, 0xA7, 0x86, 0x1E, 0xE9, 0x9F, 0xE1, 0xA7, 0x83,
  0xAE, 0x20, 0x8A, 0x0A, 0xA7, 0x86, 0xD9, 0x08, 0xF8, 0x9D, 0xA7, 0x86, 0xD9, 0x8F, 0x80, 0x9D,
  0xA7, 0x0A, 0xA8, 0x38, 0x02, 0xEA, 0xA7, 0x86, 0x1E, 0xF9, 0x9E, 0xE1, 0xA7, 0x18, 0x41, 0xAD,
  0xDA, 0x11, 0xA7, 0x71, 0xA7, 0x3A, 0x3F, 0xF3, 0xFF, 0x3F, 0xF3, 0x0D, 0xFD, 0x0D, 0x30, 0x40,
  0xDF, 0xB0, 0xD0, 0x43,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_app_blocking() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 1, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_app_blocking_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_app_shortcut 24x24, 4-bit Alpha,  RLE, 90 bytes.
static const unsigned char ic_round_24_action_app_shortcut_data[] PROGMEM = {
  0x04, 0x0D, 0xFB, 0x0D, 0x04, 0x40, 0xDF, 0xD0, 0xD4, 0xFF, 0x4F, 0xF4, 0xFF, 0x4A, 0x73, 0xA4,
  0xA7, 0x60, 0x20, 0x31, 0xA7, 0x10, 0x01, 0x28, 0x22, 0xCC, 0x3A, 0x71, 0x00, 0xA2, 0x82, 0x2C,
  0xC2, 0xA7, 0x03, 0xA0, 0x32, 0x02, 0x03, 0x1A, 0x50, 0x10, 0xAC, 0x0A, 0x01, 0x3A, 0x50, 0x10,
  0xAC, 0x0A, 0x01, 0x3A, 0x70, 0x3A, 0x03, 0x20, 0x02, 0x1A, 0x71, 0x00, 0xA2, 0x82, 0x2C, 0xC2,
  0xA7, 0x10, 0x01, 0x28, 0x22, 0xCC, 0x2A, 0x76, 0x00, 0x21, 0xA7, 0x3A, 0x4F, 0xF4, 0xFF, 0x4F,
  0xF4, 0x0D, 0xFD, 0x0D, 0x40, 0x40, 0xDF, 0xB0, 0xD0, 0x44,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_app_shortcut() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_app_shortcut_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_arrow_circle_down 24x24, 4-bit Alpha,  RLE, 130 bytes.
static const unsigned char ic_round_24_action_arrow_circle_down_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x12, 0x6C, 0xA0, 0x85, 0x08, 0xA0, 0x67, 0x10, 0x6A, 0x08, 0x30, 0x4A, 0x04, 0x73, 0x04,
  0xA0, 0x42, 0x81, 0xDF, 0x67, 0x58, 0x56, 0xFD, 0x05, 0xFC, 0x60, 0x0B, 0x68, 0x4C, 0xF5, 0x9F,
  0x66, 0xA6, 0x84, 0x6F, 0x9D, 0xF2, 0x6A, 0x68, 0x22, 0xFD, 0xE9, 0x7A, 0x79, 0x00, 0xE9, 0x40,
  0x2E, 0x02, 0x49, 0x82, 0xED, 0xF2, 0x40, 0x7C, 0x07, 0x48, 0x42, 0xFD, 0x9F, 0x65, 0x07, 0xA0,
  0x75, 0x84, 0x6F, 0x95, 0xFC, 0x60, 0x07, 0x68, 0x5C, 0xF5, 0x0D, 0xF6, 0x75, 0x81, 0x6F, 0xD2,
  0x04, 0xA0, 0x47, 0x30, 0x4A, 0x04, 0x30, 0x8A, 0x06, 0x71, 0x06, 0xA0, 0x85, 0x08, 0xA8, 0x1C,
  0x62, 0x28, 0x12, 0x6C, 0xA0, 0x87, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED,
  0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_arrow_circle_down() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_arrow_circle_down_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_arrow_circle_left 24x24, 4-bit Alpha,  RLE, 95 bytes.
static const unsigned char ic_round_24_action_arrow_circle_left_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFF, 0xA0, 0x42, 0x0D, 0xFF, 0xA8, 0x1D, 0x05, 0xF9, 0x0D, 0xFA, 0x05,
  0x09, 0xF0, 0x71, 0xFA, 0x09, 0x0D, 0xE0, 0x72, 0xFA, 0x0D, 0x0E, 0xD0, 0x86, 0x03, 0xD0, 0x0E,
  0xD0, 0x86, 0x03, 0xD0, 0xE0, 0xDE, 0x07, 0x2F, 0xA0, 0xD0, 0x9F, 0x07, 0x1F, 0xA0, 0x90, 0x5F,
  0x90, 0xCF, 0xA8, 0x15, 0x0D, 0xFF, 0xA0, 0xD2, 0x04, 0xFF, 0xA0, 0x43, 0x08, 0xFF, 0x08, 0x50,
  0x8F, 0xD0, 0x87, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_arrow_circle_left() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_arrow_circle_left_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_arrow_circle_right 24x24, 4-bit Alpha,  RLE, 95 bytes.
static const unsigned char ic_round_24_action_arrow_circle_right_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFF, 0xA0, 0x42, 0x0D, 0xFF, 0xA8, 0x1D, 0x05, 0xFA, 0x0C, 0xF9, 0x05,
  0x09, 0xFA, 0x10, 0x7F, 0x09, 0x0D, 0xFA, 0x20, 0x7E, 0x0D, 0x0E, 0xD0, 0x36, 0x08, 0xD0, 0x0E,
  0xD0, 0x36, 0x08, 0xD0, 0xE0, 0xDF, 0xA2, 0x07, 0xE0, 0xD0, 0x9F, 0xA1, 0x07, 0xF0, 0x90, 0x5F,
  0xA0, 0xDF, 0x98, 0x15, 0x0D, 0xFF, 0xA0, 0xD2, 0x04, 0xFF, 0xA0, 0x43, 0x08, 0xFF, 0x08, 0x50,
  0x8F, 0xD0, 0x87, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_arrow_circle_right() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_arrow_circle_right_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_arrow_circle_up 24x24, 4-bit Alpha,  RLE, 130 bytes.
static const unsigned char ic_round_24_action_arrow_circle_up_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x12, 0x6C, 0xA0, 0x85, 0x08, 0xA0, 0x67, 0x10, 0x6A, 0x08, 0x30, 0x4A, 0x04, 0x73, 0x04,
  0xA0, 0x42, 0x81, 0xDF, 0x67, 0x58, 0x56, 0xFD, 0x05, 0xFC, 0x60, 0x07, 0x68, 0x4C, 0xF5, 0x9F,
  0x65, 0x07, 0xA0, 0x75, 0x84, 0x6F, 0x9D, 0xF2, 0x40, 0x7C, 0x07, 0x48, 0x22, 0xFD, 0xE9, 0x40,
  0x2E, 0x02, 0x49, 0x00, 0xE9, 0x7A, 0x79, 0x82, 0xED, 0xF2, 0x6A, 0x68, 0x42, 0xFD, 0x9F, 0x66,
  0xA6, 0x84, 0x6F, 0x95, 0xFC, 0x60, 0x0B, 0x68, 0x5C, 0xF5, 0x0D, 0xF6, 0x75, 0x81, 0x6F, 0xD2,
  0x04, 0xA0, 0x47, 0x30, 0x4A, 0x04, 0x30, 0x8A, 0x06, 0x71, 0x06, 0xA0, 0x85, 0x08, 0xA8, 0x1C,
  0x62, 0x28, 0x12, 0x6C, 0xA0, 0x87, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED,
  0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_arrow_circle_up() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_arrow_circle_up_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_arrow_outward 24x24, 4-bit Alpha,  RLE, 56 bytes.
static const unsigned char ic_round_24_action_arrow_outward_data[] PROGMEM = {
  0x10, 0xBF, 0xB8, 0x1B, 0x0B, 0xFC, 0x71, 0x01, 0x0C, 0xB7, 0x82, 0x1C, 0xFC, 0xA6, 0x83, 0x1C,
  0xFC, 0x1A, 0x58, 0x31, 0xCF, 0xC1, 0x1A, 0x48, 0x31, 0xCF, 0xC1, 0x2A, 0x38, 0x31, 0xCF, 0xC1,
  0x3A, 0x28, 0x31, 0xCF, 0xC1, 0x4A, 0x18, 0x31, 0xCF, 0xC1, 0x5A, 0x83, 0x1C, 0xFC, 0x16, 0xA8,
  0x27, 0xFC, 0x17, 0x83, 0xBB, 0x17, 0x17, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_arrow_outward() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 6, 17, 18), Box(0, 0, 23, 23),
      ic_round_24_action_arrow_outward_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_arrow_right_alt 24x24, 4-bit Alpha,  RLE, 22 bytes.
static const unsigned char ic_round_24_action_arrow_right_alt_data[] PROGMEM = {
  0x75, 0x02, 0x77, 0x19, 0x07, 0x77, 0xA8, 0x17, 0x0B, 0xFF, 0x07, 0x0B, 0xFF, 0x07, 0x75, 0xA0,
  0x77, 0x69, 0x07, 0x77, 0x02, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_arrow_right_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 8, 19, 15), Box(0, 0, 23, 23),
      ic_round_24_action_arrow_right_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_article 24x24, 4-bit Alpha,  RLE, 46 bytes.
static const unsigned char ic_round_24_action_article_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xC4, 0xF0, 0x37, 0x10, 0x3F, 0x90, 0x37,
  0x10, 0x38, 0x0D, 0x0F, 0x03, 0x71, 0x03, 0xF9, 0x03, 0x71, 0x03, 0x80, 0xD0, 0xF0, 0x35, 0x03,
  0xFC, 0x03, 0x50, 0x38, 0x0C, 0x7F, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_article() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_article_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_aspect_ratio 24x24, 4-bit Alpha,  RLE, 63 bytes.
static const unsigned char ic_round_24_action_aspect_ratio_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xE0, 0xDA, 0x03, 0x77, 0x20, 0x3C, 0x77, 0x4C, 0x20,
  0xBB, 0x0B, 0x74, 0xC2, 0xC0, 0xB7, 0x4C, 0x2A, 0x77, 0xC2, 0xA7, 0x7C, 0x20, 0x0B, 0x77, 0xC7,
  0x70, 0x0B, 0x2C, 0x77, 0xA2, 0xC7, 0x7A, 0x2C, 0x74, 0x0B, 0xC2, 0xC7, 0x40, 0xBB, 0x0B, 0x2C,
  0x77, 0x4C, 0x03, 0x77, 0x20, 0x3A, 0x0D, 0xFF, 0xE8, 0x1D, 0x4D, 0xFF, 0xC0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_aspect_ratio() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_aspect_ratio_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_assessment 24x24, 4-bit Alpha,  RLE, 53 bytes.
static const unsigned char ic_round_24_action_assessment_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xD0, 0xF0, 0x03, 0xFF, 0xA2, 0xFF, 0xA2,
  0xFD, 0x00, 0x3A, 0x2F, 0xD2, 0xA2, 0xFD, 0x2A, 0x2F, 0xD2, 0xA2, 0xA0, 0x03, 0xF9, 0x2A, 0x2A,
  0x2F, 0x92, 0xA2, 0xA2, 0xF9, 0x00, 0x3A, 0x00, 0x3A, 0x00, 0x38, 0x0C, 0x4F, 0x0D, 0xFF, 0xA8,
  0x1D, 0x4D, 0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_assessment() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_assessment_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_assignment_ind 24x24, 4-bit Alpha,  RLE, 69 bytes.
static const unsigned char ic_round_24_action_assignment_ind_data[] PROGMEM = {
  0x78, 0x28, 0xEE, 0x87, 0x60, 0x8C, 0x08, 0x60, 0x40, 0xDE, 0x00, 0x3E, 0x81, 0xD4, 0xDF, 0x00,
  0x3F, 0x0D, 0x80, 0xC7, 0xF8, 0x27, 0x11, 0x7F, 0xE0, 0x74, 0x07, 0xFD, 0x01, 0x40, 0x1F, 0xD0,
  0x14, 0x01, 0xFD, 0x07, 0x40, 0x7F, 0xE8, 0x27, 0x11, 0x7F, 0xFF, 0xFB, 0x84, 0xEA, 0x78, 0xAE,
  0xFB, 0x0A, 0x03, 0x60, 0x30, 0xAF, 0x07, 0x73, 0x07, 0xE7, 0x5E, 0x75, 0xB0, 0xDF, 0xFA, 0x81,
  0xD4, 0xDF, 0xF0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_assignment_ind() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 1, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_assignment_ind_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_assignment_late 24x24, 4-bit Alpha,  RLE, 52 bytes.
static const unsigned char ic_round_24_action_assignment_late_data[] PROGMEM = {
  0x78, 0x28, 0xEE, 0x87, 0x68, 0x48, 0xFE, 0xEF, 0x86, 0x04, 0x0D, 0xE0, 0x05, 0xE8, 0x1D, 0x4D,
  0xF0, 0x0E, 0xF0, 0xD8, 0x0D, 0x0F, 0x00, 0x3F, 0xFA, 0x2F, 0xFA, 0x2F, 0xFA, 0x2F, 0xFA, 0x2F,
  0xFA, 0x00, 0x38, 0x0E, 0x0F, 0x00, 0x3F, 0xFA, 0x00, 0x38, 0x0D, 0x0F, 0x0D, 0xFF, 0xA8, 0x1D,
  0x4D, 0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_assignment_late() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 1, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_assignment_late_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_assignment 24x24, 4-bit Alpha,  RLE, 56 bytes.
static const unsigned char ic_round_24_action_assignment_data[] PROGMEM = {
  0x78, 0x28, 0xEE, 0x87, 0x60, 0x8C, 0x08, 0x60, 0x40, 0xDE, 0x00, 0x3E, 0x81, 0xD4, 0xDF, 0x00,
  0x3F, 0x0D, 0x80, 0xC4, 0xF0, 0x37, 0x10, 0x3F, 0x90, 0x37, 0x10, 0x38, 0x0D, 0x0F, 0x03, 0x71,
  0x03, 0xF9, 0x03, 0x71, 0x03, 0x80, 0xD0, 0xF0, 0x35, 0x03, 0xFC, 0x03, 0x50, 0x38, 0x0C, 0x7F,
  0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_assignment() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 1, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_assignment_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_assignment_returned 24x24, 4-bit Alpha,  RLE, 54 bytes.
static const unsigned char ic_round_24_action_assignment_returned_data[] PROGMEM = {
  0x78, 0x28, 0xEE, 0x87, 0x60, 0x8C, 0x08, 0x60, 0x40, 0xDE, 0x00, 0x3E, 0x81, 0xD4, 0xDF, 0x00,
  0x3F, 0x0D, 0x80, 0x99, 0x3F, 0x4F, 0xF4, 0xFF, 0x4F, 0xF4, 0xFC, 0x07, 0x71, 0x07, 0xFA, 0x07,
  0x60, 0x7F, 0xC0, 0x74, 0x07, 0xFE, 0x07, 0x20, 0x7F, 0xF9, 0x00, 0x8F, 0xFF, 0xD0, 0xDF, 0xFA,
  0x81, 0xD4, 0xDF, 0xF0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_assignment_returned() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 1, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_assignment_returned_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_assignment_return 24x24, 4-bit Alpha,  RLE, 57 bytes.
static const unsigned char ic_round_24_action_assignment_return_data[] PROGMEM = {
  0x78, 0x28, 0xEE, 0x87, 0x60, 0x8C, 0x08, 0x60, 0x40, 0xDE, 0x00, 0x3E, 0x81, 0xD4, 0xDF, 0x00,
  0x3F, 0x0D, 0x80, 0xF2, 0xF0, 0x7F, 0xFA, 0x07, 0x1F, 0xF9, 0x07, 0x2F, 0xF0, 0x77, 0xFA, 0x08,
  0x71, 0xFA, 0x08, 0x71, 0xFB, 0x07, 0x7F, 0xC0, 0x72, 0xFF, 0xA0, 0x71, 0xFF, 0xB0, 0x7F, 0xFF,
  0xE0, 0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xF0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_assignment_return() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 1, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_assignment_return_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_assignment_turned_in 24x24, 4-bit Alpha,  RLE, 66 bytes.
static const unsigned char ic_round_24_action_assignment_turned_in_data[] PROGMEM = {
  0x78, 0x28, 0xEE, 0x87, 0x60, 0x8C, 0x08, 0x60, 0x40, 0xDE, 0x00, 0x3E, 0x81, 0xD4, 0xDF, 0x00,
  0x3F, 0x0D, 0x80, 0xF6, 0xF8, 0x1A, 0x1A, 0xFF, 0x0A, 0x20, 0xAF, 0xE0, 0xA2, 0x07, 0xFE, 0x0A,
  0x20, 0x7F, 0x98, 0x1A, 0x1A, 0xA0, 0xA2, 0x07, 0xFA, 0x09, 0x20, 0x0A, 0x20, 0x7F, 0xC0, 0x74,
  0x07, 0xFE, 0x07, 0x20, 0x7F, 0xF9, 0x00, 0xA8, 0x0D, 0x2F, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF,
  0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_assignment_turned_in() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 1, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_assignment_turned_in_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_assured_workload 24x24, 4-bit Alpha,  RLE, 117 bytes.
static const unsigned char ic_round_24_action_assured_workload_data[] PROGMEM = {
  0x71, 0x82, 0x39, 0x93, 0x77, 0x20, 0x30, 0xBC, 0x0B, 0x03, 0x75, 0x03, 0x0B, 0xF9, 0x0B, 0x03,
  0x71, 0x03, 0x0B, 0xFD, 0x0B, 0x03, 0x40, 0x30, 0xBF, 0xFA, 0x0B, 0x03, 0x20, 0xEF, 0xFC, 0x0E,
  0x20, 0xAF, 0xFC, 0x0A, 0x80, 0xD5, 0x00, 0x0B, 0x40, 0x0B, 0x40, 0x0B, 0x71, 0xA4, 0xA4, 0xA7,
  0x1A, 0x4A, 0x40, 0xE0, 0x77, 0x1A, 0x4A, 0x40, 0x17, 0x2A, 0x4A, 0x58, 0x23, 0xBB, 0x35, 0xA4,
  0xA3, 0x03, 0x0B, 0xC0, 0xB0, 0x33, 0x00, 0xB4, 0x00, 0xB3, 0x0E, 0xC8, 0x1E, 0xFE, 0x77, 0xC8,
  0x1A, 0x0A, 0x97, 0x79, 0x86, 0xC5, 0x90, 0x3E, 0xFB, 0xFC, 0x82, 0x20, 0xDC, 0x28, 0x33, 0xEF,
  0xDB, 0xFC, 0x85, 0x40, 0x9F, 0xC8, 0xEA, 0x09, 0x77, 0x02, 0xE0, 0x27, 0x71, 0x05, 0xC0, 0x57,
  0x73, 0x82, 0x4B, 0xB4, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_assured_workload() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 1, 23, 23), Box(0, 0, 23, 23),
      ic_round_24_action_assured_workload_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_autorenew 24x24, 4-bit Alpha,  RLE, 97 bytes.
static const unsigned char ic_round_24_action_autorenew_data[] PROGMEM = {
  0x71, 0x02, 0x77, 0x19, 0x07, 0x77, 0xA0, 0x77, 0x28, 0x22, 0x8C, 0xEB, 0x07, 0x70, 0x9F, 0x07,
  0x60, 0xBA, 0x08, 0x03, 0x1A, 0x07, 0x68, 0x29, 0xFD, 0x23, 0x90, 0x76, 0x02, 0xA0, 0x24, 0x02,
  0x48, 0x41, 0x71, 0x8F, 0x87, 0x38, 0x46, 0xF8, 0xCF, 0x37, 0x38, 0x23, 0xFC, 0xE9, 0x75, 0x90,
  0x0E, 0x97, 0x59, 0x82, 0xEC, 0xF3, 0x73, 0x84, 0x3F, 0xC8, 0xF6, 0x73, 0x84, 0x8F, 0x81, 0x71,
  0x40, 0x24, 0x02, 0xA0, 0x26, 0x07, 0x93, 0x82, 0x2D, 0xF9, 0x60, 0x7A, 0x10, 0x30, 0x8A, 0x0B,
  0x60, 0x7F, 0x09, 0x70, 0x7B, 0x82, 0xEC, 0x82, 0x72, 0x07, 0xA7, 0x70, 0x79, 0x77, 0x10, 0x27,
  0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_autorenew() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 1, 19, 22), Box(0, 0, 23, 23),
      ic_round_24_action_autorenew_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_backup 24x24, 4-bit Alpha,  RLE, 86 bytes.
static const unsigned char ic_round_24_action_backup_data[] PROGMEM = {
  0x78, 0x61, 0x7C, 0xFE, 0xC7, 0x17, 0x60, 0x50, 0xEE, 0x0E, 0x05, 0x74, 0x05, 0xFB, 0x05, 0x72,
  0x01, 0x0E, 0xFB, 0x0E, 0x01, 0x71, 0x07, 0xFD, 0x07, 0x68, 0x11, 0x8E, 0xD0, 0x08, 0xD0, 0xC5,
  0x03, 0x0E, 0xE0, 0x72, 0x07, 0xC0, 0xE4, 0x01, 0x0E, 0xE0, 0x74, 0x07, 0xC0, 0xD0, 0x72, 0x08,
  0xE0, 0xC6, 0x0D, 0xD8, 0x1B, 0x0C, 0xFA, 0x2F, 0xA0, 0x70, 0xEF, 0xA2, 0xFA, 0x0C, 0x0D, 0xFA,
  0x00, 0x3F, 0xA0, 0xE0, 0x9F, 0xFE, 0x81, 0xC1, 0xEF, 0xFD, 0x82, 0x70, 0x4E, 0xFF, 0xB0, 0xB3,
  0x81, 0x29, 0xDF, 0xE0, 0xC0, 0x62,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_backup() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 4, 22, 19), Box(0, 0, 23, 23),
      ic_round_24_action_backup_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_backup_table 24x24, 4-bit Alpha,  RLE, 64 bytes.
static const unsigned char ic_round_24_action_backup_table_data[] PROGMEM = {
  0x40, 0x40, 0xDF, 0xD0, 0xD0, 0x44, 0x0D, 0xFF, 0x0D, 0x4A, 0x75, 0xA4, 0xA7, 0x5A, 0x00, 0xB2,
  0xA7, 0x5C, 0x2A, 0x75, 0xC2, 0xA7, 0x5C, 0x2F, 0xFC, 0x2F, 0xFC, 0x2A, 0x5A, 0x5C, 0x2A, 0x5A,
  0x5C, 0x2A, 0x5A, 0x5C, 0x2A, 0x5A, 0x5C, 0x2A, 0x5A, 0x5C, 0x20, 0xDF, 0xF0, 0xDA, 0x20, 0x40,
  0xDF, 0xD0, 0xD0, 0x4A, 0x77, 0x4A, 0x77, 0x40, 0xDF, 0xF0, 0xB4, 0x04, 0x0D, 0xFE, 0x0B, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_backup_table() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_backup_table_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_balance 24x24, 4-bit Alpha,  RLE, 118 bytes.
static const unsigned char ic_round_24_action_balance_data[] PROGMEM = {
  0x71, 0x82, 0x8E, 0xE8, 0x77, 0x10, 0x8C, 0x08, 0x71, 0x0B, 0xF0, 0x03, 0xF0, 0xB2, 0x0B, 0xF0,
  0x03, 0xF0, 0xB3, 0x81, 0x3F, 0x32, 0x08, 0xC0, 0x82, 0x81, 0x3F, 0x34, 0x81, 0x9F, 0x93, 0x08,
  0xA0, 0x83, 0x81, 0x9F, 0x93, 0x83, 0x1F, 0xEF, 0x13, 0xA3, 0x83, 0x1F, 0xEF, 0x12, 0x83, 0x7F,
  0x4F, 0x73, 0xA3, 0x83, 0x7F, 0x4F, 0x72, 0x83, 0xDA, 0x0A, 0xD3, 0xA3, 0x89, 0x3D, 0xA0, 0xAD,
  0x05, 0xF4, 0x04, 0xF5, 0x2A, 0x28, 0x75, 0xF4, 0x04, 0xF5, 0xBD, 0x30, 0xD0, 0xB2, 0xA2, 0x0B,
  0x0D, 0x38, 0x1D, 0xBD, 0xD0, 0xD2, 0xA2, 0x0D, 0xD0, 0xD0, 0x7D, 0x07, 0x2A, 0x20, 0x7D, 0x85,
  0x70, 0x6C, 0xFC, 0x63, 0xA3, 0x83, 0x6C, 0xFC, 0x67, 0x3A, 0x77, 0x4A, 0x77, 0x4A, 0x72, 0x0B,
  0xFF, 0xC0, 0x0B, 0xFF, 0xC0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_balance() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_balance_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_batch_prediction 24x24, 4-bit Alpha,  RLE, 63 bytes.
static const unsigned char ic_round_24_action_batch_prediction_data[] PROGMEM = {
  0x20, 0x8F, 0x90, 0x84, 0x80, 0x67, 0x77, 0x30, 0x8F, 0xB0, 0x82, 0x80, 0x90, 0x77, 0x71, 0x04,
  0x0D, 0xFB, 0x81, 0xD4, 0xDC, 0x82, 0xD9, 0x9D, 0xC0, 0xDC, 0x09, 0x40, 0x9F, 0x0D, 0x60, 0xDE,
  0x09, 0x60, 0x9E, 0x09, 0x60, 0x9E, 0x0E, 0x60, 0xEF, 0x09, 0x40, 0x9F, 0xA0, 0x52, 0x05, 0xFB,
  0x0C, 0x20, 0xCF, 0xFF, 0xC2, 0xE0, 0xDD, 0x00, 0xAD, 0x81, 0xD4, 0xDF, 0xB0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_batch_prediction() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 2, 18, 21), Box(0, 0, 23, 23),
      ic_round_24_action_batch_prediction_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_bookmark_added 24x24, 4-bit Alpha,  RLE, 69 bytes.
static const unsigned char ic_round_24_action_bookmark_added_data[] PROGMEM = {
  0x04, 0x0D, 0xE0, 0xB6, 0x82, 0x7D, 0x2D, 0xF0, 0x45, 0x07, 0xA0, 0x2F, 0x98, 0x41, 0x03, 0xB3,
  0x7A, 0x05, 0x1F, 0x92, 0x06, 0xC0, 0x52, 0xF9, 0x03, 0x20, 0xAA, 0x05, 0x3F, 0x90, 0xA3, 0x06,
  0x03, 0x4F, 0xA0, 0x77, 0x1F, 0xB0, 0xA0, 0x36, 0xFF, 0x4F, 0xF4, 0xFF, 0x4F, 0xF4, 0xFF, 0x4F,
  0xF4, 0xFF, 0x4D, 0x82, 0x93, 0x39, 0xD4, 0x83, 0xEF, 0xD7, 0x14, 0x83, 0x17, 0xDF, 0xE4, 0x04,
  0x05, 0x73, 0x05, 0x04, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_bookmark_added() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_bookmark_added_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_bookmark_add 24x24, 4-bit Alpha,  RLE, 62 bytes.
static const unsigned char ic_round_24_action_bookmark_add_data[] PROGMEM = {
  0x04, 0x0D, 0xE0, 0xB3, 0x00, 0xB2, 0x0D, 0xF0, 0x43, 0xA2, 0xF9, 0x81, 0x10, 0xBC, 0x0B, 0xF9,
  0x20, 0xBC, 0x0B, 0xF9, 0x03, 0x3A, 0x2F, 0x90, 0xA3, 0x00, 0xB2, 0xFA, 0x07, 0x6F, 0xB0, 0xA0,
  0x34, 0xFF, 0x2F, 0xF2, 0xFF, 0x2F, 0xF2, 0xFF, 0x2F, 0xF2, 0xFF, 0x2D, 0x82, 0x93, 0x39, 0xD2,
  0x83, 0xEF, 0xD7, 0x14, 0x83, 0x17, 0xDF, 0xE2, 0x04, 0x05, 0x73, 0x05, 0x04, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_bookmark_add() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_bookmark_add_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_bookmark_border 24x24, 4-bit Alpha,  RLE, 52 bytes.
static const unsigned char ic_round_24_action_bookmark_border_data[] PROGMEM = {
  0x04, 0x0D, 0xFB, 0x81, 0xD4, 0xDF, 0xD0, 0xDA, 0x03, 0x71, 0x03, 0xC7, 0x3C, 0x73, 0xC7, 0x3C,
  0x73, 0xC7, 0x3C, 0x73, 0xC7, 0x3C, 0x73, 0xC7, 0x3C, 0x73, 0xC2, 0x84, 0x18, 0xEE, 0x81, 0x2C,
  0x03, 0x0A, 0xE0, 0xA0, 0x3F, 0x82, 0x93, 0x39, 0xF8, 0x1E, 0x71, 0x48, 0x11, 0x7E, 0xA0, 0xC0,
  0x57, 0x30, 0x50, 0xC0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_bookmark_border() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 18, 20), Box(0, 0, 23, 23),
      ic_round_24_action_bookmark_border_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_bookmark 24x24, 4-bit Alpha,  RLE, 25 bytes.
static const unsigned char ic_round_24_action_bookmark_data[] PROGMEM = {
  0x04, 0x0D, 0xFB, 0x81, 0xD4, 0xDF, 0xD0, 0xD8, 0x0A, 0xE7, 0xF8, 0x29, 0x33, 0x9F, 0x81, 0xE7,
  0x14, 0x81, 0x17, 0xEA, 0x0C, 0x05, 0x73, 0x05, 0x0C,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_bookmark() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 18, 20), Box(0, 0, 23, 23),
      ic_round_24_action_bookmark_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_bookmark_remove 24x24, 4-bit Alpha,  RLE, 56 bytes.
static const unsigned char ic_round_24_action_bookmark_remove_data[] PROGMEM = {
  0x04, 0x0D, 0xE0, 0xB7, 0x0D, 0xF0, 0x47, 0xF9, 0x81, 0x10, 0xBC, 0x0B, 0xF9, 0x20, 0xBC, 0x0B,
  0xF9, 0x03, 0x7F, 0x90, 0xA7, 0xFA, 0x07, 0x6F, 0xB0, 0xA0, 0x34, 0xFF, 0x2F, 0xF2, 0xFF, 0x2F,
  0xF2, 0xFF, 0x2F, 0xF2, 0xFF, 0x2D, 0x82, 0x93, 0x39, 0xD2, 0x83, 0xEF, 0xD7, 0x14, 0x83, 0x17,
  0xDF, 0xE2, 0x04, 0x05, 0x73, 0x05, 0x04, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_bookmark_remove() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_bookmark_remove_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_bookmarks 24x24, 4-bit Alpha,  RLE, 70 bytes.
static const unsigned char ic_round_24_action_bookmarks_data[] PROGMEM = {
  0x40, 0x40, 0xDF, 0xB0, 0xD0, 0x44, 0x0D, 0xFD, 0x0D, 0x77, 0x01, 0x0B, 0xA7, 0x71, 0x01, 0xA0,
  0x40, 0xDF, 0xB0, 0xD0, 0x42, 0xA0, 0xDF, 0xD0, 0xD2, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF,
  0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF,
  0xA2, 0x03, 0x0B, 0xFF, 0x4D, 0x82, 0x93, 0x39, 0xD4, 0xA8, 0x1E, 0x71, 0x48, 0x11, 0x7E, 0xA4,
  0x0C, 0x05, 0x73, 0x05, 0x0C, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_bookmarks() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 1, 20, 22), Box(0, 0, 23, 23),
      ic_round_24_action_bookmarks_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_book_online 24x24, 4-bit Alpha,  RLE, 62 bytes.
static const unsigned char ic_round_24_action_book_online_data[] PROGMEM = {
  0x04, 0x0D, 0xFB, 0x81, 0xD4, 0xDF, 0xD0, 0xD8, 0x0D, 0x0F, 0x73, 0xC7, 0x3C, 0x10, 0xBE, 0x0B,
  0x1C, 0x1B, 0x00, 0xCB, 0x1C, 0x1B, 0x00, 0xCB, 0x1C, 0x10, 0x5A, 0x00, 0xCA, 0x03, 0x1C, 0x10,
  0x2A, 0x00, 0xCA, 0x03, 0x1C, 0x1B, 0x00, 0xCB, 0x1C, 0x1B, 0x00, 0xCB, 0x1C, 0x10, 0xBE, 0x0B,
  0x1C, 0x73, 0xC7, 0x38, 0x0D, 0x0F, 0x0D, 0xFD, 0x81, 0xD4, 0xDF, 0xB0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_book_online() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 1, 18, 22), Box(0, 0, 23, 23),
      ic_round_24_action_book_online_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_book 24x24, 4-bit Alpha,  RLE, 34 bytes.
static const unsigned char ic_round_24_action_book_data[] PROGMEM = {
  0x04, 0x0D, 0xFD, 0x81, 0xD4, 0xDF, 0xF0, 0xDA, 0x5F, 0xC5, 0xFC, 0x5F, 0xC5, 0xFC, 0x5F, 0xC5,
  0xFC, 0x20, 0x52, 0xFC, 0x83, 0x4D, 0xFD, 0x48, 0x0A, 0x85, 0xF0, 0xDF, 0xF8, 0x1D, 0x4D, 0xFD,
  0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_book() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_book_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_browse_gallery 24x24, 4-bit Alpha,  RLE, 141 bytes.
static const unsigned char ic_round_24_action_browse_gallery_data[] PROGMEM = {
  0x58, 0x64, 0x9D, 0xEE, 0xD9, 0x47, 0x70, 0x20, 0xBF, 0x90, 0xB0, 0x23, 0x81, 0xAB, 0x15, 0x03,
  0x0E, 0xFB, 0x0E, 0x03, 0x28, 0x2C, 0xFE, 0x33, 0x02, 0x0E, 0xFD, 0x86, 0xE2, 0x01, 0xAF, 0xE1,
  0x20, 0xBE, 0x00, 0x3E, 0x0B, 0x38, 0x3A, 0xFB, 0x04, 0xF2, 0xF0, 0x42, 0x83, 0x1E, 0xF3, 0x9F,
  0x2F, 0x09, 0x38, 0x28, 0xF9, 0xDF, 0x2F, 0x0D, 0x38, 0x23, 0xFC, 0xEF, 0x20, 0xEE, 0x0E, 0x38,
  0x21, 0xFE, 0xEF, 0x82, 0x40, 0x2E, 0xD0, 0xE3, 0x82, 0x1F, 0xED, 0xF8, 0x3E, 0x20, 0x2E, 0xC0,
  0xD3, 0x82, 0x3F, 0xC9, 0xF9, 0x82, 0xE2, 0x05, 0xC0, 0x93, 0x82, 0x8F, 0x94, 0xFA, 0x81, 0xE5,
  0xAC, 0x04, 0x28, 0x41, 0xEF, 0x30, 0xBF, 0xF0, 0xB3, 0x81, 0xAF, 0xB2, 0x02, 0x0E, 0xFD, 0x86,
  0xE2, 0x01, 0xAF, 0xE1, 0x30, 0x30, 0xEF, 0xB0, 0xE0, 0x32, 0x82, 0xCF, 0xE3, 0x50, 0x20, 0xBF,
  0x90, 0xB0, 0x23, 0x81, 0xAB, 0x17, 0x18, 0x64, 0x9D, 0xEE, 0xD9, 0x47, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_browse_gallery() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 3, 23, 20), Box(0, 0, 23, 23),
      ic_round_24_action_browse_gallery_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_bug_report 24x24, 4-bit Alpha,  RLE, 81 bytes.
static const unsigned char ic_round_24_action_bug_report_data[] PROGMEM = {
  0x38, 0x11, 0x71, 0x48, 0x11, 0x71, 0x68, 0x27, 0xFC, 0x12, 0x82, 0x1C, 0xF7, 0x68, 0x90, 0x1C,
  0xFE, 0xEE, 0xEF, 0xC1, 0x60, 0x10, 0xCE, 0x0C, 0x01, 0x60, 0xCF, 0x90, 0xC3, 0x0B, 0xFF, 0x00,
  0xBF, 0xF0, 0xB2, 0x0E, 0xB0, 0x32, 0x03, 0xB0, 0xE4, 0xC0, 0x32, 0x03, 0xC2, 0x0B, 0xFF, 0x00,
  0xBF, 0xF0, 0xB2, 0xC0, 0x32, 0x03, 0xC4, 0x0E, 0xB0, 0x32, 0x03, 0xB0, 0xE2, 0x0B, 0xFF, 0x00,
  0xBF, 0xF0, 0xB3, 0x0C, 0xF9, 0x0C, 0x60, 0x10, 0xCE, 0x0C, 0x01, 0x71, 0x84, 0x6C, 0xEE, 0xC6,
  0x50,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_bug_report() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 3, 19, 20), Box(0, 0, 23, 23),
      ic_round_24_action_bug_report_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_build_circle 24x24, 4-bit Alpha,  RLE, 115 bytes.
static const unsigned char ic_round_24_action_build_circle_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xD0, 0xD0, 0xBF, 0xA0, 0x42, 0x0D, 0xC0, 0xD0, 0x12, 0x0A, 0xF8, 0x1D,
  0x05, 0xC8, 0x2D, 0xFC, 0x12, 0x0C, 0xF0, 0x50, 0x9B, 0x83, 0xD1, 0xCF, 0xA2, 0x06, 0xF0, 0x90,
  0xDB, 0x83, 0xC0, 0x1A, 0x12, 0x05, 0xF0, 0xD0, 0xEC, 0x01, 0x50, 0x4F, 0x00, 0xEC, 0x0A, 0x60,
  0x6E, 0x0E, 0x0D, 0xD8, 0x2C, 0x65, 0x43, 0x06, 0xD0, 0xD0, 0x9F, 0xA0, 0x63, 0x07, 0xC0, 0x90,
  0x5F, 0xB0, 0x62, 0x05, 0xC8, 0x15, 0x0D, 0xFB, 0x81, 0x75, 0xEB, 0x0D, 0x20, 0x4F, 0xFA, 0x04,
  0x30, 0x8F, 0xF0, 0x85, 0x08, 0xFD, 0x08, 0x70, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x38, 0x65, 0x9D,
  0xEE, 0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_build_circle() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_build_circle_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_build 24x24, 4-bit Alpha,  RLE, 109 bytes.
static const unsigned char ic_round_24_action_build_data[] PROGMEM = {
  0x38, 0x51, 0x9D, 0xDD, 0x93, 0x77, 0x20, 0x8D, 0x08, 0x77, 0x20, 0x8D, 0x08, 0x73, 0x01, 0x50,
  0x8D, 0x03, 0x72, 0x09, 0x07, 0x50, 0xAC, 0x09, 0x72, 0x81, 0xDF, 0x74, 0x0A, 0xC0, 0xD7, 0x20,
  0xEA, 0x07, 0x20, 0x7D, 0x0E, 0x72, 0x0D, 0xB0, 0x90, 0xAE, 0x0D, 0x72, 0x09, 0xFC, 0x09, 0x72,
  0x03, 0xFC, 0x0E, 0x03, 0x72, 0x08, 0xFC, 0x0E, 0x03, 0x72, 0x08, 0xFC, 0x0E, 0x03, 0x72, 0x84,
  0x39, 0xDE, 0xDA, 0xE0, 0xE0, 0x37, 0x70, 0x4E, 0x0E, 0x03, 0x77, 0x04, 0xE0, 0xE0, 0x37, 0x70,
  0x4E, 0x0E, 0x03, 0x77, 0x04, 0xE0, 0xE0, 0x37, 0x70, 0x4E, 0x0D, 0x77, 0x10, 0x4E, 0x02, 0x77,
  0x10, 0x4D, 0x01, 0x77, 0x20, 0x40, 0xEA, 0x06, 0x77, 0x48, 0x11, 0x31, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_build() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_build_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_cached 24x24, 4-bit Alpha,  RLE, 91 bytes.
static const unsigned char ic_round_24_action_cached_data[] PROGMEM = {
  0x78, 0x62, 0x8C, 0xEE, 0xC8, 0x17, 0x60, 0x9F, 0x08, 0x75, 0x0B, 0xA0, 0x80, 0x32, 0x81, 0x37,
  0x17, 0x48, 0x29, 0xFD, 0x27, 0x73, 0x02, 0xA0, 0x27, 0x30, 0x07, 0x68, 0x18, 0xF8, 0x73, 0x07,
  0xA0, 0x75, 0x81, 0xCF, 0x37, 0x20, 0x7C, 0x07, 0x40, 0xE9, 0x72, 0x02, 0xE0, 0x02, 0xE0, 0x27,
  0x29, 0x0E, 0x40, 0x7C, 0x07, 0x72, 0x81, 0x3F, 0xC5, 0x07, 0xA0, 0x77, 0x38, 0x18, 0xF8, 0x60,
  0x07, 0x73, 0x02, 0xA0, 0x27, 0x73, 0x82, 0x2D, 0xF9, 0x74, 0x81, 0x17, 0x32, 0x03, 0x08, 0xA0,
  0xB7, 0x50, 0x8F, 0x09, 0x76, 0x86, 0x18, 0xCE, 0xEC, 0x82, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_cached() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 4, 22, 19), Box(0, 0, 23, 23),
      ic_round_24_action_cached_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_calendar_month 24x24, 4-bit Alpha,  RLE, 64 bytes.
static const unsigned char ic_round_24_action_calendar_month_data[] PROGMEM = {
  0x30, 0x0B, 0x71, 0x00, 0xB6, 0xA7, 0x1A, 0x30, 0x40, 0xDF, 0xF8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD8,
  0x09, 0x86, 0xF7, 0x7C, 0x77, 0xC2, 0x00, 0xB2, 0x00, 0xB2, 0x00, 0xB2, 0xC2, 0x00, 0xB2, 0x00,
  0xB2, 0x00, 0xB2, 0xC7, 0x7C, 0x77, 0xC2, 0x00, 0xB2, 0x00, 0xB2, 0x00, 0xB2, 0xC2, 0x00, 0xB2,
  0x00, 0xB2, 0x00, 0xB2, 0xC7, 0x7C, 0x77, 0xA0, 0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xF0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_calendar_month() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_calendar_month_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_calendar_today 24x24, 4-bit Alpha,  RLE, 55 bytes.
static const unsigned char ic_round_24_action_calendar_today_data[] PROGMEM = {
  0x30, 0x0B, 0x73, 0x00, 0xB6, 0xA7, 0x3A, 0x30, 0x40, 0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xFC, 0x0D,
  0x80, 0xF2, 0xF7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72,
  0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC0, 0x37, 0x70, 0x3A, 0x0D, 0xFF,
  0xC8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_calendar_today() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 1, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_calendar_today_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_calendar_view_day 24x24, 4-bit Alpha,  RLE, 37 bytes.
static const unsigned char ic_round_24_action_calendar_view_day_data[] PROGMEM = {
  0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB8, 0x0C, 0x00, 0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA,
  0x0D, 0x80, 0x9D, 0x0F, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0x0D, 0x04, 0x80, 0xC0, 0x00, 0xBF,
  0xFA, 0x00, 0xBF, 0xFA, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_calendar_view_day() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_calendar_view_day_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_calendar_view_month 24x24, 4-bit Alpha,  RLE, 50 bytes.
static const unsigned char ic_round_24_action_calendar_view_month_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDA, 0x4A, 0x4A, 0x4C, 0x4A, 0x4A, 0x4C, 0x4A,
  0x4A, 0x4C, 0x4A, 0x4A, 0x4C, 0x4A, 0x4A, 0x48, 0x0D, 0x0F, 0x4A, 0x4A, 0x4C, 0x4A, 0x4A, 0x4C,
  0x4A, 0x4A, 0x4C, 0x4A, 0x4A, 0x4C, 0x4A, 0x4A, 0x4A, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xA0,
  0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_calendar_view_month() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_calendar_view_month_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_calendar_view_week 24x24, 4-bit Alpha,  RLE, 114 bytes.
static const unsigned char ic_round_24_action_calendar_view_week_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDA, 0x28, 0x17, 0xF7, 0x2A, 0x28, 0x17, 0xF7,
  0x2C, 0x28, 0x17, 0xF7, 0x2A, 0x28, 0x17, 0xF7, 0x2C, 0x28, 0x17, 0xF7, 0x2A, 0x28, 0x17, 0xF7,
  0x2C, 0x28, 0x17, 0xF7, 0x2A, 0x28, 0x17, 0xF7, 0x2C, 0x28, 0x17, 0xF7, 0x2A, 0x28, 0x17, 0xF7,
  0x2C, 0x28, 0x17, 0xF7, 0x2A, 0x28, 0x17, 0xF7, 0x2C, 0x28, 0x17, 0xF7, 0x2A, 0x28, 0x17, 0xF7,
  0x2C, 0x28, 0x17, 0xF7, 0x2A, 0x28, 0x17, 0xF7, 0x2C, 0x28, 0x17, 0xF7, 0x2A, 0x28, 0x17, 0xF7,
  0x2C, 0x28, 0x17, 0xF7, 0x2A, 0x28, 0x17, 0xF7, 0x2C, 0x28, 0x17, 0xF7, 0x2A, 0x28, 0x17, 0xF7,
  0x2C, 0x28, 0x17, 0xF7, 0x2A, 0x28, 0x17, 0xF7, 0x2A, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xA0,
  0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_calendar_view_week() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_calendar_view_week_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_camera_enhance 24x24, 4-bit Alpha,  RLE, 89 bytes.
static const unsigned char ic_round_24_action_camera_enhance_data[] PROGMEM = {
  0x60, 0x60, 0xEC, 0x0E, 0x06, 0x74, 0x05, 0xF9, 0x05, 0x50, 0x40, 0xDF, 0xFA, 0x81, 0xD4, 0xDF,
  0xFC, 0x0D, 0xFF, 0xFE, 0x0A, 0x03, 0x20, 0x30, 0xAF, 0xE0, 0x72, 0x00, 0x32, 0x07, 0xFC, 0x0A,
  0x30, 0x0A, 0x30, 0xAF, 0xB0, 0x32, 0x03, 0xA0, 0x32, 0x03, 0xFB, 0x10, 0x30, 0xAC, 0x0A, 0x03,
  0x1F, 0xB1, 0x03, 0x0A, 0xC0, 0xA0, 0x31, 0xFB, 0x03, 0x20, 0x3A, 0x03, 0x20, 0x3F, 0xB0, 0xA3,
  0x00, 0xA3, 0x0A, 0xFC, 0x07, 0x20, 0x03, 0x20, 0x7F, 0xE0, 0xA0, 0x32, 0x03, 0x0A, 0xFF, 0xFE,
  0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_camera_enhance() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_camera_enhance_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_cancel_schedule_send 24x24, 4-bit Alpha,  RLE, 145 bytes.
static const unsigned char ic_round_24_action_cancel_schedule_send_data[] PROGMEM = {
  0x04, 0x05, 0x77, 0x78, 0x3E, 0xFE, 0x71, 0x77, 0x4D, 0x0A, 0x03, 0x77, 0x2F, 0x0C, 0x05, 0x77,
  0xFA, 0x81, 0xE7, 0x17, 0x4F, 0xD0, 0xA0, 0x37, 0x20, 0xDF, 0xE8, 0x3E, 0xFD, 0xA5, 0x48, 0x21,
  0x58, 0xCF, 0xF9, 0x0C, 0x02, 0x78, 0x23, 0x6A, 0xDB, 0x89, 0x0D, 0x62, 0x02, 0x6D, 0xFE, 0x26,
  0x82, 0x36, 0xAD, 0xA0, 0xB7, 0x86, 0xBF, 0xC0, 0x15, 0x8C, 0xE0, 0xD7, 0x28, 0x2D, 0xF5, 0xDF,
  0xA0, 0x62, 0x83, 0x73, 0x03, 0x72, 0x81, 0x6F, 0xAF, 0xB0, 0x12, 0x83, 0x3E, 0x7E, 0x32, 0x81,
  0x1F, 0xDF, 0xB4, 0x81, 0x7F, 0x74, 0xFA, 0x82, 0xCE, 0xF1, 0x28, 0x33, 0xE7, 0xE3, 0x28, 0x11,
  0xFD, 0xD8, 0x4A, 0x30, 0xAF, 0x62, 0x83, 0x73, 0x03, 0x72, 0x86, 0x6F, 0xAE, 0xFE, 0x71, 0x38,
  0x15, 0xFD, 0x72, 0x83, 0xDF, 0x54, 0x57, 0x81, 0xCF, 0xB7, 0x81, 0xBF, 0xC7, 0x38, 0x93, 0x2E,
  0xFD, 0x62, 0x02, 0x6D, 0xFE, 0x27, 0x40, 0x20, 0xCF, 0x0C, 0x02, 0x77, 0x85, 0x5A, 0xDF, 0xDA,
  0x54,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_cancel_schedule_send() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 23, 23), Box(0, 0, 23, 23),
      ic_round_24_action_cancel_schedule_send_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_card_giftcard 24x24, 4-bit Alpha,  RLE, 88 bytes.
static const unsigned char ic_round_24_action_card_giftcard_data[] PROGMEM = {
  0x58, 0x28, 0xDE, 0x82, 0x82, 0x8E, 0xD8, 0x72, 0x08, 0xC0, 0x09, 0xC0, 0x87, 0x18, 0x2D, 0xF3,
  0x3C, 0x82, 0x33, 0xFD, 0x71, 0x82, 0xEF, 0x33, 0xC8, 0x23, 0x3F, 0xE4, 0x04, 0x0D, 0xFF, 0xA8,
  0x1D, 0x4D, 0xF9, 0x00, 0xDF, 0x90, 0xDA, 0x03, 0x30, 0x4A, 0x00, 0x3A, 0x04, 0x30, 0x3C, 0x38,
  0x21, 0xEF, 0x72, 0x82, 0x7F, 0xE1, 0x3C, 0x38, 0x17, 0xFB, 0x48, 0x1B, 0xF7, 0x3C, 0x38, 0x12,
  0x71, 0x48, 0x11, 0x82, 0x3C, 0x77, 0x2C, 0x77, 0x28, 0x0F, 0x4F, 0x77, 0x2C, 0x77, 0x2A, 0x0D,
  0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_card_giftcard() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_card_giftcard_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_card_membership 24x24, 4-bit Alpha,  RLE, 54 bytes.
static const unsigned char ic_round_24_action_card_membership_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDA, 0x03, 0x77, 0x03, 0xC7, 0x72, 0xC7, 0x72,
  0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0x80, 0xF4, 0xF7, 0x72, 0xC7, 0x72, 0xA0, 0xDF, 0xFC, 0x81,
  0xD4, 0xDF, 0xFA, 0x0D, 0x04, 0x6F, 0x97, 0x5F, 0x97, 0x5F, 0x97, 0x5A, 0x82, 0xB3, 0x3B, 0xA7,
  0x50, 0xB0, 0x34, 0x03, 0x0B, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_card_membership() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_card_membership_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_card_travel 24x24, 4-bit Alpha,  RLE, 56 bytes.
static const unsigned char ic_round_24_action_card_travel_data[] PROGMEM = {
  0x50, 0x40, 0xDE, 0x0D, 0x04, 0x73, 0x0D, 0xF9, 0x0D, 0x73, 0xA6, 0xA7, 0x3A, 0x6A, 0x50, 0x40,
  0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xFC, 0x0D, 0xA0, 0x32, 0xA6, 0xA2, 0x03, 0xC3, 0x00, 0xB6, 0x00,
  0xB3, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0x80, 0xF4, 0xF7, 0x72, 0xC7, 0x72, 0xA0,
  0xDF, 0xFC, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_card_travel() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_card_travel_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_change_history 24x24, 4-bit Alpha,  RLE, 86 bytes.
static const unsigned char ic_round_24_action_change_history_data[] PROGMEM = {
  0x72, 0x00, 0xD7, 0x73, 0x08, 0xA0, 0x87, 0x71, 0x03, 0xC0, 0x37, 0x78, 0x4C, 0xF8, 0x8F, 0xC7,
  0x68, 0x16, 0xFD, 0x28, 0x1D, 0xF6, 0x74, 0x82, 0x1E, 0xF4, 0x28, 0x24, 0xFE, 0x17, 0x38, 0x1A,
  0xFA, 0x48, 0x1A, 0xFA, 0x72, 0x82, 0x4F, 0xE1, 0x48, 0x21, 0xEF, 0x47, 0x18, 0x1D, 0xF6, 0x68,
  0x16, 0xFD, 0x78, 0x18, 0xFC, 0x71, 0x81, 0xCF, 0x85, 0x03, 0xA0, 0x27, 0x10, 0x2A, 0x03, 0x48,
  0x1C, 0xF8, 0x73, 0x81, 0x8F, 0xC3, 0x81, 0x6F, 0xD7, 0x58, 0x4D, 0xF6, 0x01, 0xEF, 0xFA, 0x82,
  0xE1, 0x1D, 0xFF, 0xA0, 0xD0, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_change_history() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 5, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_change_history_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_check_circle_outline 24x24, 4-bit Alpha,  RLE, 145 bytes.
static const unsigned char ic_round_24_action_check_circle_outline_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x12, 0x6C, 0xA0, 0x85, 0x08, 0xA0, 0x67, 0x10, 0x6A, 0x08, 0x30, 0x4A, 0x04, 0x73, 0x04,
  0xA0, 0x42, 0x81, 0xDF, 0x67, 0x58, 0x56, 0xFD, 0x05, 0xFC, 0x73, 0x89, 0x05, 0xD5, 0x0C, 0xF5,
  0x9F, 0x67, 0x20, 0x5A, 0x86, 0x50, 0x6F, 0x9D, 0xF2, 0x71, 0x05, 0xA0, 0x72, 0x82, 0x2F, 0xDE,
  0x97, 0x10, 0x5A, 0x07, 0x49, 0x00, 0xE9, 0x28, 0x15, 0xD5, 0x20, 0x5A, 0x07, 0x59, 0x84, 0xED,
  0xF2, 0x05, 0xA0, 0x05, 0xA0, 0x75, 0x84, 0x2F, 0xD9, 0xF6, 0x20, 0x7C, 0x07, 0x68, 0x46, 0xF9,
  0x5F, 0xC3, 0x07, 0xA0, 0x77, 0x85, 0xCF, 0x50, 0xDF, 0x63, 0x00, 0x57, 0x81, 0x6F, 0xD2, 0x04,
  0xA0, 0x47, 0x30, 0x4A, 0x04, 0x30, 0x8A, 0x06, 0x71, 0x06, 0xA0, 0x85, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x12, 0x6C, 0xA0, 0x87, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95,
  0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_check_circle_outline() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_check_circle_outline_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_check_circle 24x24, 4-bit Alpha,  RLE, 111 bytes.
static const unsigned char ic_round_24_action_check_circle_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFF, 0xA0, 0x42, 0x0D, 0xFD, 0x85, 0xA1, 0xAF, 0xD0, 0x5F, 0xD0, 0xA2,
  0x0A, 0xA0, 0x50, 0x9F, 0xC0, 0xA2, 0x07, 0xB0, 0x90, 0xDF, 0xB0, 0xA2, 0x07, 0xC0, 0xD0, 0xEA,
  0x81, 0xA1, 0xAC, 0x0A, 0x20, 0x7D, 0x00, 0xEA, 0x09, 0x20, 0xAA, 0x0A, 0x20, 0x7E, 0x0E, 0x0D,
  0xB0, 0x72, 0x00, 0xA2, 0x07, 0xF0, 0xD0, 0x9C, 0x07, 0x40, 0x7F, 0x90, 0x90, 0x5D, 0x07, 0x20,
  0x7F, 0xA8, 0x15, 0x0D, 0xD0, 0x0A, 0xFA, 0x0D, 0x20, 0x4F, 0xFA, 0x04, 0x30, 0x8F, 0xF0, 0x85,
  0x08, 0xFD, 0x08, 0x70, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x38, 0x65, 0x9D, 0xEE, 0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_check_circle() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_check_circle_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_chrome_reader_mode 24x24, 4-bit Alpha,  RLE, 65 bytes.
static const unsigned char ic_round_24_action_chrome_reader_mode_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xE0, 0xDF, 0xC7, 0x10, 0x3F, 0xE7, 0x2F, 0xE7, 0x2F,
  0xE1, 0x05, 0x80, 0x17, 0x05, 0x1F, 0xE1, 0x0C, 0xD0, 0xC1, 0xFE, 0x72, 0xFE, 0x10, 0xCD, 0x0C,
  0x1F, 0xE1, 0x05, 0x80, 0x17, 0x05, 0x1F, 0xE1, 0x05, 0x80, 0x17, 0x05, 0x1F, 0xE1, 0x0C, 0xD0,
  0xC1, 0xFE, 0x72, 0xFE, 0x72, 0xFE, 0x71, 0x03, 0xA0, 0xDF, 0xFE, 0x81, 0xD4, 0xDF, 0xFC, 0x0D,
  0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_chrome_reader_mode() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 4, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_chrome_reader_mode_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_circle_notifications 24x24, 4-bit Alpha,  RLE, 105 bytes.
static const unsigned char ic_round_24_action_circle_notifications_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8E, 0x00, 0xAE, 0x08, 0x30, 0x4F, 0x2F, 0x04, 0x20, 0xDD, 0x0D, 0x05, 0x20, 0x50, 0xDD, 0x81,
  0xD0, 0x5D, 0x0D, 0x01, 0x40, 0x10, 0xDD, 0x05, 0x09, 0xD0, 0x56, 0x05, 0xD0, 0x90, 0xDD, 0x01,
  0x60, 0x1D, 0x0D, 0x0E, 0xD7, 0x1D, 0x00, 0xED, 0x71, 0xD0, 0xE0, 0xDD, 0x71, 0xD0, 0xD0, 0x9C,
  0x03, 0x71, 0x03, 0xC0, 0x90, 0x5C, 0x03, 0x71, 0x03, 0xC8, 0x15, 0x0D, 0xFF, 0xA0, 0xD2, 0x04,
  0xE0, 0x92, 0x09, 0xE0, 0x43, 0x08, 0xE0, 0x09, 0xE0, 0x85, 0x08, 0xFD, 0x08, 0x70, 0x40, 0xDF,
  0x90, 0xD0, 0x47, 0x38, 0x65, 0x9D, 0xEE, 0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_circle_notifications() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_circle_notifications_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_class 24x24, 4-bit Alpha,  RLE, 34 bytes.
static const unsigned char ic_round_24_action_class_data[] PROGMEM = {
  0x04, 0x0D, 0xFD, 0x81, 0xD4, 0xDF, 0xF0, 0xDA, 0x5F, 0xC5, 0xFC, 0x5F, 0xC5, 0xFC, 0x5F, 0xC5,
  0xFC, 0x20, 0x52, 0xFC, 0x83, 0x4D, 0xFD, 0x48, 0x0A, 0x85, 0xF0, 0xDF, 0xF8, 0x1D, 0x4D, 0xFD,
  0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_class() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_class_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_close_fullscreen 24x24, 4-bit Alpha,  RLE, 85 bytes.
static const unsigned char ic_round_24_action_close_fullscreen_data[] PROGMEM = {
  0x77, 0x38, 0x11, 0x71, 0x77, 0x28, 0x21, 0xCF, 0x77, 0x71, 0x83, 0x1C, 0xFC, 0x17, 0x30, 0x05,
  0x28, 0x31, 0xCF, 0xC1, 0x74, 0xA8, 0x47, 0x1C, 0xFC, 0x17, 0x5B, 0x82, 0xEF, 0xC1, 0x76, 0xC0,
  0xE0, 0x17, 0x7D, 0x07, 0x77, 0xE0, 0x57, 0x60, 0xCD, 0x05, 0x60, 0x5D, 0x0C, 0x76, 0x05, 0xE7,
  0x70, 0x7D, 0x77, 0x01, 0x0E, 0xC7, 0x68, 0x21, 0xCF, 0xEB, 0x75, 0x84, 0x1C, 0xFC, 0x17, 0xA7,
  0x48, 0x31, 0xCF, 0xC1, 0x20, 0x05, 0x73, 0x83, 0x1C, 0xFC, 0x17, 0x71, 0x82, 0x7F, 0xC1, 0x77,
  0x28, 0x11, 0x71, 0x77, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_close_fullscreen() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_close_fullscreen_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_code_off 24x24, 4-bit Alpha,  RLE, 119 bytes.
static const unsigned char ic_round_24_action_code_off_data[] PROGMEM = {
  0x10, 0x90, 0x67, 0x74, 0x01, 0xA0, 0x77, 0x74, 0x05, 0xA0, 0x77, 0x74, 0x05, 0xA0, 0x77, 0x10,
  0x05, 0x71, 0x05, 0xA0, 0x77, 0x81, 0xDF, 0x77, 0x10, 0xAA, 0x07, 0x60, 0x5A, 0x07, 0x60, 0x7C,
  0x07, 0x60, 0x5A, 0x07, 0x40, 0x7A, 0x00, 0x5A, 0x07, 0x60, 0x5A, 0x07, 0x20, 0x5A, 0x05, 0x20,
  0x5A, 0x07, 0x60, 0x5A, 0x81, 0x50, 0x5A, 0x05, 0x30, 0x5A, 0x07, 0x50, 0x5A, 0x05, 0x20, 0x7A,
  0x05, 0x30, 0x5A, 0x07, 0x30, 0x5A, 0x07, 0x40, 0x7A, 0x05, 0x30, 0x5A, 0x07, 0x28, 0x19, 0xF7,
  0x60, 0x7A, 0x05, 0x30, 0x5A, 0x07, 0x20, 0x57, 0x18, 0x17, 0xFD, 0x40, 0x5A, 0x07, 0x74, 0x00,
  0x55, 0x05, 0xA0, 0x77, 0x74, 0x05, 0xA0, 0x77, 0x74, 0x05, 0xA0, 0x77, 0x74, 0x05, 0xA0, 0x67,
  0x74, 0x81, 0x5F, 0x97, 0x75, 0x01, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_code_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_code_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_code 24x24, 4-bit Alpha,  RLE, 72 bytes.
static const unsigned char ic_round_24_action_code_data[] PROGMEM = {
  0x50, 0x05, 0x60, 0x05, 0x72, 0x81, 0x7F, 0xD6, 0x81, 0xDF, 0x77, 0x07, 0xA0, 0x46, 0x04, 0xA0,
  0x75, 0x07, 0xA0, 0x47, 0x10, 0x4A, 0x07, 0x30, 0x7A, 0x04, 0x73, 0x04, 0xA8, 0x17, 0x05, 0xA0,
  0x47, 0x50, 0x4A, 0x00, 0x5A, 0x04, 0x75, 0x04, 0xA8, 0x15, 0x07, 0xA0, 0x47, 0x30, 0x4A, 0x07,
  0x30, 0x7A, 0x04, 0x71, 0x04, 0xA0, 0x75, 0x07, 0xA0, 0x46, 0x04, 0xA0, 0x77, 0x81, 0x7F, 0xD6,
  0x81, 0xDF, 0x77, 0x20, 0x05, 0x60, 0x05, 0x50,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_code() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 6, 21, 17), Box(0, 0, 23, 23),
      ic_round_24_action_code_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_comment_bank 24x24, 4-bit Alpha,  RLE, 45 bytes.
static const unsigned char ic_round_24_action_comment_bank_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDF, 0xD5, 0xFF, 0x95, 0xFF, 0x95, 0xFF, 0x95,
  0xFF, 0x95, 0xFF, 0x95, 0xFF, 0x92, 0x05, 0x2F, 0xF9, 0x83, 0x8D, 0xFD, 0x88, 0x09, 0xC2, 0xF0,
  0xDF, 0xFC, 0x0D, 0x04, 0xB0, 0x77, 0x72, 0xA0, 0x77, 0x73, 0x00, 0x57, 0x74,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_comment_bank() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_comment_bank_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_commit 24x24, 4-bit Alpha,  RLE, 55 bytes.
static const unsigned char ic_round_24_action_commit_data[] PROGMEM = {
  0x78, 0x43, 0xBE, 0xEB, 0x37, 0x60, 0x7E, 0x07, 0x74, 0x04, 0xA8, 0x27, 0x11, 0x7A, 0x04, 0x73,
  0x81, 0xAF, 0x74, 0x81, 0x7F, 0xA5, 0x0B, 0xE0, 0x14, 0x01, 0xE0, 0x0B, 0xE0, 0x14, 0x01, 0xE0,
  0xB5, 0x81, 0xAF, 0x74, 0x81, 0x7F, 0xA7, 0x30, 0x4A, 0x82, 0x71, 0x17, 0xA0, 0x47, 0x40, 0x7E,
  0x07, 0x76, 0x84, 0x3B, 0xEE, 0xB3, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_commit() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 7, 21, 16), Box(0, 0, 23, 23),
      ic_round_24_action_commit_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_commute 24x24, 4-bit Alpha,  RLE, 84 bytes.
static const unsigned char ic_round_24_action_commute_data[] PROGMEM = {
  0x10, 0x80, 0xDF, 0x0D, 0x08, 0x71, 0x08, 0xFC, 0x08, 0x78, 0x1D, 0xF1, 0x78, 0x11, 0xFD, 0x7A,
  0x72, 0xA7, 0xA7, 0x74, 0xA7, 0x06, 0xF9, 0x06, 0x1A, 0x70, 0xD0, 0x46, 0x03, 0x0D, 0x1A, 0x60,
  0x30, 0xD7, 0x10, 0xD0, 0x3A, 0x01, 0x50, 0x80, 0xB7, 0x10, 0xA0, 0x8F, 0x10, 0xDF, 0xB0, 0xDA,
  0x00, 0x3B, 0x19, 0x00, 0x3E, 0x85, 0x33, 0xFD, 0xF3, 0x3B, 0x19, 0x00, 0x3E, 0x82, 0x33, 0xF8,
  0xE1, 0xFD, 0x10, 0x80, 0xDC, 0x1F, 0xD2, 0x81, 0x7F, 0x73, 0xA7, 0x1A, 0x20, 0xC0, 0x74, 0x0B,
  0x0C, 0x71, 0x0B, 0x0C,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_commute() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_commute_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_compare_arrows 24x24, 4-bit Alpha,  RLE, 47 bytes.
static const unsigned char ic_round_24_action_compare_arrows_data[] PROGMEM = {
  0x75, 0x02, 0x77, 0x40, 0x79, 0x77, 0x30, 0x7A, 0x77, 0x20, 0x7F, 0xA0, 0xB7, 0x20, 0x7F, 0xA0,
  0xB7, 0x30, 0x7A, 0x77, 0x02, 0x30, 0x79, 0x77, 0x90, 0x73, 0x02, 0x77, 0xA0, 0x77, 0x30, 0xBF,
  0xA0, 0x77, 0x20, 0xBF, 0xA0, 0x77, 0x72, 0xA0, 0x77, 0x73, 0x90, 0x77, 0x74, 0x02, 0x75,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_compare_arrows() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 5, 21, 18), Box(0, 0, 23, 23),
      ic_round_24_action_compare_arrows_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_compress 24x24, 4-bit Alpha,  RLE, 53 bytes.
static const unsigned char ic_round_24_action_compress_data[] PROGMEM = {
  0x70, 0x0B, 0x77, 0xA7, 0x7A, 0x74, 0x02, 0xE0, 0x27, 0x20, 0x7C, 0x07, 0x74, 0x07, 0xA0, 0x77,
  0x60, 0x07, 0x77, 0x72, 0x0B, 0xFF, 0x00, 0xBF, 0xF0, 0xB7, 0x72, 0x0B, 0xFF, 0x00, 0xBF, 0xF0,
  0xB7, 0x77, 0x20, 0x07, 0x76, 0x07, 0xA0, 0x77, 0x40, 0x7C, 0x07, 0x72, 0x02, 0xE0, 0x27, 0x4A,
  0x77, 0xA7, 0x70, 0x0B, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_compress() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 1, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_compress_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_contactless 24x24, 4-bit Alpha,  RLE, 124 bytes.
static const unsigned char ic_round_24_action_contactless_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFF, 0xA0, 0x42, 0x0D, 0xFA, 0x81, 0xA1, 0xEC, 0x81, 0xD0, 0x5F, 0x84,
  0xB8, 0xFC, 0x09, 0xD0, 0x50, 0x9C, 0x87, 0xEE, 0xF8, 0x0E, 0xF1, 0x5D, 0x09, 0x0D, 0xC8, 0x76,
  0x4F, 0xC0, 0xAF, 0x52, 0xD0, 0xD0, 0xEC, 0x86, 0x61, 0xFE, 0x08, 0xF6, 0x1D, 0x00, 0xEC, 0x86,
  0x61, 0xFE, 0x08, 0xF6, 0x1D, 0x0E, 0x0D, 0xC8, 0x75, 0x4F, 0xD0, 0x9F, 0x52, 0xD0, 0xD0, 0x9C,
  0x87, 0xEE, 0xF8, 0x0D, 0xF1, 0x5D, 0x09, 0x05, 0xF8, 0x4B, 0x7F, 0xC0, 0xAD, 0x81, 0x50, 0xDF,
  0xA8, 0x1A, 0x1E, 0xC0, 0xD2, 0x04, 0xFF, 0xA0, 0x43, 0x08, 0xFF, 0x08, 0x50, 0x8F, 0xD0, 0x87,
  0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_contactless() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_contactless_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_contact_page 24x24, 4-bit Alpha,  RLE, 60 bytes.
static const unsigned char ic_round_24_action_contact_page_data[] PROGMEM = {
  0x04, 0x0D, 0xF0, 0xE0, 0x65, 0x0D, 0xFB, 0x07, 0x4F, 0xD0, 0x73, 0xFE, 0x07, 0x2F, 0xF0, 0x71,
  0xFF, 0x90, 0x6F, 0xF9, 0x0E, 0xFF, 0xF9, 0x82, 0xB1, 0x1B, 0xFD, 0x01, 0x20, 0x1F, 0xD0, 0x12,
  0x01, 0xFD, 0x82, 0xB1, 0x1B, 0xFF, 0xFD, 0x81, 0xE7, 0x22, 0x81, 0x27, 0xEF, 0x90, 0x46, 0x04,
  0xF9, 0x71, 0x80, 0xC0, 0xF0, 0xDF, 0xF8, 0x1D, 0x4D, 0xFD, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_contact_page() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_contact_page_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_contact_support 24x24, 4-bit Alpha,  RLE, 109 bytes.
static const unsigned char ic_round_24_action_contact_support_data[] PROGMEM = {
  0x58, 0x56, 0xBD, 0xFD, 0xB6, 0x71, 0x05, 0x0E, 0xF0, 0xE0, 0x55, 0x07, 0xB8, 0x39, 0x20, 0x29,
  0xB0, 0x73, 0x05, 0xB0, 0x65, 0x07, 0xB0, 0x52, 0x0E, 0xA0, 0xC2, 0x81, 0xAE, 0x92, 0x0D, 0xA8,
  0x1E, 0x06, 0xB8, 0x1C, 0x08, 0xB8, 0x15, 0x09, 0xB0, 0x60, 0xBF, 0xA8, 0x15, 0x09, 0xB0, 0xB0,
  0xDF, 0x98, 0x2A, 0x01, 0xEB, 0x0D, 0xF9, 0x82, 0x90, 0x1C, 0xD0, 0xDE, 0x0C, 0x20, 0xCD, 0x0E,
  0x0B, 0xE8, 0x18, 0x06, 0xE0, 0xB0, 0x6F, 0xF9, 0x81, 0x80, 0xED, 0x81, 0xB7, 0xBE, 0x81, 0x20,
  0x5D, 0x81, 0x70, 0x7D, 0x0B, 0x30, 0x7C, 0x81, 0xB7, 0xBD, 0x02, 0x40, 0x50, 0xEF, 0xA0, 0x77,
  0x81, 0x6B, 0xDD, 0x0A, 0x75, 0xB0, 0x97, 0x6A, 0x06, 0x77, 0x0B, 0x02, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_contact_support() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_contact_support_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_copyright 24x24, 4-bit Alpha,  RLE, 154 bytes.
static const unsigned char ic_round_24_action_copyright_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x12, 0x6C, 0xA0, 0x85, 0x08, 0xA0, 0x67, 0x10, 0x6A, 0x08, 0x30, 0x4A, 0x04, 0x73, 0x04,
  0xA0, 0x42, 0x81, 0xDF, 0x64, 0x81, 0x25, 0x45, 0x85, 0x6F, 0xD0, 0x5F, 0xC4, 0x09, 0xB0, 0xE0,
  0x44, 0x84, 0xCF, 0x59, 0xF6, 0x38, 0x56, 0xFC, 0x35, 0xEE, 0x48, 0x46, 0xF9, 0xDF, 0x23, 0x81,
  0xCF, 0x32, 0x81, 0x6B, 0x23, 0x82, 0x2F, 0xDE, 0x94, 0x0E, 0x97, 0x39, 0x00, 0xE9, 0x40, 0xE9,
  0x73, 0x98, 0x2E, 0xDF, 0x23, 0x81, 0xCF, 0x32, 0x81, 0x59, 0x23, 0x84, 0x2F, 0xD9, 0xF6, 0x38,
  0x56, 0xFC, 0x24, 0xEE, 0x48, 0x46, 0xF9, 0x5F, 0xC4, 0x09, 0xB0, 0xD0, 0x34, 0x85, 0xCF, 0x50,
  0xDF, 0x64, 0x81, 0x25, 0x45, 0x81, 0x6F, 0xD2, 0x04, 0xA0, 0x47, 0x30, 0x4A, 0x04, 0x30, 0x8A,
  0x06, 0x71, 0x06, 0xA0, 0x85, 0x08, 0xA8, 0x1C, 0x62, 0x28, 0x12, 0x6C, 0xA0, 0x87, 0x04, 0x0D,
  0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_copyright() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_copyright_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_credit_card_off 24x24, 4-bit Alpha,  RLE, 101 bytes.
static const unsigned char ic_round_24_action_credit_card_off_data[] PROGMEM = {
  0x03, 0x04, 0x77, 0x58, 0x1C, 0xF7, 0x77, 0x40, 0x5A, 0x07, 0x20, 0xAF, 0xD8, 0x2D, 0x40, 0xDA,
  0x07, 0x20, 0xAF, 0xD0, 0xD1, 0xC0, 0x72, 0x0A, 0xFD, 0x1D, 0x07, 0x20, 0xAF, 0xC1, 0xA1, 0x05,
  0xA0, 0x77, 0x4A, 0x1A, 0x20, 0x5A, 0x07, 0x73, 0xA1, 0xA3, 0x05, 0xA0, 0x77, 0x2A, 0x1A, 0x40,
  0x5A, 0x07, 0x71, 0xA1, 0xFB, 0x07, 0x20, 0xAE, 0x1F, 0xC0, 0x72, 0x0A, 0xD1, 0xFD, 0x07, 0x20,
  0xAC, 0x1F, 0xE0, 0x72, 0x0A, 0xB1, 0xFF, 0x07, 0x20, 0xAA, 0x1F, 0xF9, 0x07, 0x28, 0x2A, 0xF0,
  0xDF, 0xF9, 0x07, 0x28, 0x28, 0x04, 0xDF, 0xF9, 0x07, 0x77, 0x40, 0x5A, 0x07, 0x77, 0x40, 0x5A,
  0x04, 0x77, 0x48, 0x15, 0xC3,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_credit_card_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_credit_card_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_credit_card 24x24, 4-bit Alpha,  RLE, 38 bytes.
static const unsigned char ic_round_24_action_credit_card_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDA, 0x77, 0x2C, 0x77, 0x28, 0x09, 0xA0, 0xF7,
  0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC0, 0x37, 0x70, 0x3A, 0x0D, 0xFF, 0xC8,
  0x1D, 0x4D, 0xFF, 0xA0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_credit_card() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_credit_card_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_css 24x24, 4-bit Alpha,  RLE, 55 bytes.
static const unsigned char ic_round_24_action_css_data[] PROGMEM = {
  0x0B, 0xB8, 0x1B, 0x04, 0xC8, 0x14, 0x0B, 0xB8, 0xA3, 0xBF, 0xB7, 0x9C, 0x07, 0xF7, 0x7D, 0x50,
  0xFB, 0x79, 0xCF, 0x74, 0x89, 0x47, 0xF7, 0x77, 0x10, 0xFB, 0x77, 0x4F, 0x74, 0x89, 0x11, 0x77,
  0x7F, 0x70, 0x47, 0x7B, 0xA8, 0xA0, 0xB7, 0x9C, 0x05, 0xD7, 0x7F, 0x70, 0xC9, 0x7B, 0xFB, 0xB8,
  0x1B, 0x04, 0xC8, 0x14, 0x0B, 0xB0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_css() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 9, 20, 14), Box(0, 0, 23, 23),
      ic_round_24_action_css_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_currency_exchange 24x24, 4-bit Alpha,  RLE, 190 bytes.
static const unsigned char ic_round_24_action_currency_exchange_data[] PROGMEM = {
  0x68, 0x71, 0x6A, 0xDE, 0xEC, 0xA5, 0x75, 0x07, 0x0E, 0xF9, 0x0E, 0x07, 0x71, 0x01, 0x0C, 0xA8,
  0x6B, 0x62, 0x01, 0x25, 0xCA, 0x83, 0xC1, 0x0B, 0xB2, 0x83, 0x1D, 0xFD, 0x37, 0x18, 0x33, 0xDF,
  0xD1, 0xA2, 0x81, 0xCF, 0xB5, 0x00, 0xA4, 0x82, 0x1C, 0xFC, 0xA1, 0x82, 0x7F, 0xD1, 0x30, 0x10,
  0x8A, 0x08, 0x01, 0x30, 0x10, 0xDB, 0x18, 0x1E, 0xF3, 0x48, 0x4D, 0xFE, 0xDF, 0xD2, 0x0B, 0xD8,
  0x16, 0xFB, 0x48, 0x15, 0xF8, 0x28, 0x36, 0xC1, 0x0B, 0xC8, 0x2B, 0xAF, 0x54, 0x81, 0x7F, 0x57,
  0x58, 0x1D, 0xF2, 0x48, 0x32, 0xFE, 0x61, 0x73, 0x00, 0xB6, 0x05, 0x0E, 0xA0, 0x90, 0x27, 0x74,
  0x83, 0x6C, 0xFE, 0x35, 0x00, 0xB7, 0x58, 0x16, 0xFB, 0x48, 0x12, 0xFD, 0x70, 0x30, 0x84, 0x0E,
  0x0D, 0x48, 0x25, 0xFA, 0xBC, 0x83, 0xB0, 0x8F, 0x92, 0x81, 0x4F, 0xB4, 0x81, 0xBF, 0x6D, 0x89,
  0x0B, 0x01, 0xCF, 0xED, 0xFE, 0x33, 0x81, 0x3F, 0xE1, 0xB0, 0xD0, 0x14, 0x83, 0x7E, 0xF9, 0x23,
  0x82, 0x1D, 0xF7, 0x1A, 0x82, 0xCF, 0xC1, 0x40, 0x0A, 0x58, 0x1B, 0xFC, 0x2A, 0x83, 0x1D, 0xFD,
  0x37, 0x18, 0x33, 0xDF, 0xD1, 0x28, 0x3B, 0xB0, 0x1C, 0xA8, 0x6C, 0x52, 0x10, 0x26, 0xBA, 0x0C,
  0x01, 0x71, 0x07, 0x0E, 0xF9, 0x0E, 0x07, 0x75, 0x87, 0x5A, 0xCE, 0xED, 0xA6, 0x16,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_currency_exchange() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_currency_exchange_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_dangerous 24x24, 4-bit Alpha,  RLE, 103 bytes.
static const unsigned char ic_round_24_action_dangerous_data[] PROGMEM = {
  0x40, 0x30, 0xDE, 0x0D, 0x03, 0x70, 0x40, 0xEF, 0x90, 0xE0, 0x35, 0x04, 0x0E, 0xFB, 0x0E, 0x03,
  0x30, 0x40, 0xEF, 0xD8, 0x3E, 0x30, 0x3E, 0xFF, 0x81, 0xE3, 0xDC, 0x81, 0x95, 0xEA, 0x81, 0xE5,
  0x9C, 0x0D, 0xD8, 0x64, 0x02, 0xEE, 0x20, 0x5F, 0xB8, 0x6E, 0x20, 0x22, 0x02, 0xEF, 0xC0, 0xE0,
  0x22, 0x02, 0x0E, 0xFD, 0x0E, 0x02, 0x20, 0x20, 0xEF, 0xC8, 0x6E, 0x20, 0x22, 0x02, 0xEF, 0xB8,
  0x65, 0x02, 0xEE, 0x20, 0x5D, 0x0D, 0xC8, 0x19, 0x5E, 0xA8, 0x1E, 0x59, 0xC8, 0x1D, 0x3E, 0xFF,
  0x83, 0xE3, 0x03, 0xEF, 0xD0, 0xE0, 0x33, 0x03, 0x0E, 0xFB, 0x0E, 0x03, 0x50, 0x30, 0xEF, 0x90,
  0xE0, 0x37, 0x03, 0x0D, 0xE0, 0xD0, 0x34,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_dangerous() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_dangerous_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_dashboard_customize 24x24, 4-bit Alpha,  RLE, 54 bytes.
static const unsigned char ic_round_24_action_dashboard_customize_data[] PROGMEM = {
  0x0B, 0xE0, 0xB2, 0x0B, 0xE0, 0xBF, 0x92, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF,
  0xA2, 0xF9, 0x0B, 0xE0, 0xB2, 0x0B, 0xE0, 0xB8, 0x0C, 0x00, 0x0B, 0xE0, 0xB5, 0x00, 0xB3, 0xF9,
  0x5A, 0x3F, 0x95, 0xA3, 0xF9, 0x20, 0xBE, 0x0B, 0xF9, 0x20, 0xBE, 0x0B, 0xF9, 0x5A, 0x3F, 0x95,
  0xA3, 0x0B, 0xE0, 0xB5, 0x00, 0xB3,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_dashboard_customize() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_dashboard_customize_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_dashboard 24x24, 4-bit Alpha,  RLE, 51 bytes.
static const unsigned char ic_round_24_action_dashboard_data[] PROGMEM = {
  0x0B, 0xE0, 0xB2, 0x0B, 0xE0, 0xBF, 0x92, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0x0B,
  0xE0, 0xBF, 0x97, 0x3F, 0x97, 0x3F, 0x92, 0x0B, 0xE0, 0x0B, 0xE0, 0xB2, 0xF9, 0x73, 0xF9, 0x73,
  0xF9, 0x0B, 0xE0, 0xB2, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0xF9, 0x0B, 0xE0, 0xB2,
  0x0B, 0xE0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_dashboard() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_dashboard_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_data_exploration 24x24, 4-bit Alpha,  RLE, 120 bytes.
static const unsigned char ic_round_24_action_data_exploration_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFF, 0xA0, 0x42, 0x0D, 0xFF, 0xA8, 0x1D, 0x05, 0xFB, 0x03, 0x30, 0x3B,
  0x05, 0x09, 0xFB, 0x03, 0x4B, 0x09, 0x0D, 0xFB, 0x0E, 0x02, 0x3B, 0x0D, 0x0E, 0xB8, 0x2D, 0x21,
  0xBA, 0x82, 0xE2, 0x02, 0x2B, 0x00, 0xEA, 0x0D, 0x01, 0x38, 0x69, 0xE2, 0x02, 0xE3, 0x3C, 0x85,
  0xDF, 0xD1, 0x03, 0x72, 0x82, 0x10, 0x2E, 0xF8, 0x69, 0xD2, 0x03, 0xEF, 0x92, 0x02, 0x0E, 0xF9,
  0x83, 0x32, 0x03, 0xEB, 0x81, 0xB7, 0xEF, 0xA2, 0x03, 0x0E, 0xFF, 0xA1, 0x01, 0x0E, 0xFF, 0xB2,
  0x07, 0xFE, 0x81, 0xE8, 0xE9, 0x30, 0x8F, 0xD8, 0x18, 0x08, 0x94, 0x04, 0x0D, 0xFB, 0x82, 0xE8,
  0xED, 0x68, 0x24, 0xAC, 0xEF, 0x90, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_data_exploration() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_data_exploration_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_data_thresholding 24x24, 4-bit Alpha,  RLE, 80 bytes.
static const unsigned char ic_round_24_action_data_thresholding_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xD4, 0xF8, 0x15, 0x0D, 0xFB, 0x0A, 0x0E,
  0xA0, 0x52, 0x0D, 0xFA, 0x83, 0x50, 0x1D, 0x52, 0x0C, 0xFA, 0x05, 0x60, 0xCF, 0xA0, 0x52, 0x0B,
  0x03, 0x20, 0xCF, 0xA0, 0xB2, 0x83, 0xBF, 0xE8, 0xCF, 0xC0, 0x80, 0xC8, 0x0D, 0x6F, 0x18, 0x92,
  0xBF, 0x50, 0xBF, 0x42, 0xED, 0x25, 0xD8, 0x94, 0xBF, 0x50, 0xBF, 0x42, 0xED, 0x25, 0xFB, 0xD8,
  0x92, 0x50, 0xBF, 0x42, 0xED, 0x25, 0xFB, 0x1A, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_data_thresholding() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_data_thresholding_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_date_range 24x24, 4-bit Alpha,  RLE, 50 bytes.
static const unsigned char ic_round_24_action_date_range_data[] PROGMEM = {
  0x30, 0x0B, 0x71, 0x00, 0xB6, 0xA7, 0x1A, 0x30, 0x40, 0xDF, 0xF8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD8,
  0x0E, 0x4F, 0x77, 0xC7, 0x7C, 0x2A, 0x2A, 0x2A, 0x2C, 0x2A, 0x2A, 0x2A, 0x2C, 0x77, 0xC7, 0x7C,
  0x77, 0xC7, 0x7C, 0x77, 0xC7, 0x7C, 0x03, 0x75, 0x03, 0xA0, 0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xF0,
  0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_date_range() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_date_range_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_delete_forever 24x24, 4-bit Alpha,  RLE, 65 bytes.
static const unsigned char ic_round_24_action_delete_forever_data[] PROGMEM = {
  0x30, 0x10, 0xCC, 0x0C, 0x01, 0x30, 0xBF, 0xD0, 0x0B, 0xFD, 0x0B, 0x77, 0x1F, 0xD2, 0xFD, 0x2F,
  0xD2, 0xFD, 0x2B, 0x84, 0x13, 0xEE, 0x31, 0xB2, 0xB8, 0x42, 0x02, 0x20, 0x3B, 0x2B, 0x0E, 0x02,
  0x20, 0x20, 0xEB, 0x2B, 0x0E, 0x02, 0x20, 0x20, 0xEB, 0x2B, 0x84, 0x30, 0x22, 0x03, 0xB2, 0xB8,
  0x41, 0x3E, 0xE3, 0x1B, 0x2F, 0xD2, 0xFD, 0x20, 0xDF, 0xB0, 0xD2, 0x04, 0x0D, 0xF9, 0x0D, 0x04,
  0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_delete_forever() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 18, 20), Box(0, 0, 23, 23),
      ic_round_24_action_delete_forever_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_delete_outline 24x24, 4-bit Alpha,  RLE, 59 bytes.
static const unsigned char ic_round_24_action_delete_outline_data[] PROGMEM = {
  0x30, 0x10, 0xCC, 0x0C, 0x01, 0x30, 0xBF, 0xD0, 0x0B, 0xFD, 0x0B, 0x77, 0x10, 0x40, 0xDF, 0x90,
  0xD0, 0x42, 0x0D, 0xFB, 0x0D, 0x2A, 0x03, 0x60, 0x3A, 0x2A, 0x71, 0xA2, 0xA7, 0x1A, 0x2A, 0x71,
  0xA2, 0xA7, 0x1A, 0x2A, 0x71, 0xA2, 0xA7, 0x1A, 0x2A, 0x71, 0xA2, 0xA7, 0x1A, 0x2A, 0x03, 0x60,
  0x3A, 0x20, 0xDF, 0xB0, 0xD2, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_delete_outline() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 18, 20), Box(0, 0, 23, 23),
      ic_round_24_action_delete_outline_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_delete 24x24, 4-bit Alpha,  RLE, 46 bytes.
static const unsigned char ic_round_24_action_delete_data[] PROGMEM = {
  0x30, 0x10, 0xCC, 0x0C, 0x01, 0x30, 0xBF, 0xD0, 0x0B, 0xFD, 0x0B, 0x77, 0x10, 0x40, 0xDF, 0x90,
  0xD0, 0x42, 0x0D, 0xFB, 0x0D, 0x2F, 0xD2, 0xFD, 0x2F, 0xD2, 0xFD, 0x2F, 0xD2, 0xFD, 0x2F, 0xD2,
  0xFD, 0x2F, 0xD2, 0xFD, 0x20, 0xDF, 0xB0, 0xD2, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_delete() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 18, 20), Box(0, 0, 23, 23),
      ic_round_24_action_delete_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_density_large 24x24, 4-bit Alpha,  RLE, 16 bytes.
static const unsigned char ic_round_24_action_density_large_data[] PROGMEM = {
  0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB8, 0x0B, 0xF0, 0x00, 0xBF, 0xFA, 0x00, 0xBF, 0xFA, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_density_large() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_density_large_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_density_medium 24x24, 4-bit Alpha,  RLE, 26 bytes.
static const unsigned char ic_round_24_action_density_medium_data[] PROGMEM = {
  0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB8, 0x09, 0xD0, 0x00, 0xBF, 0xFA, 0x00, 0xBF, 0xFA, 0x0B,
  0x80, 0x9D, 0x00, 0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_density_medium() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_density_medium_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_density_small 24x24, 4-bit Alpha,  RLE, 35 bytes.
static const unsigned char ic_round_24_action_density_small_data[] PROGMEM = {
  0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB8, 0x09, 0x84, 0x00, 0xBF, 0xFA, 0x00, 0xBF, 0xFA, 0x0B,
  0x80, 0x98, 0x40, 0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB8, 0x09, 0x84, 0x00, 0xBF, 0xFA, 0x00,
  0xBF, 0xFA, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_density_small() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_density_small_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_description 24x24, 4-bit Alpha,  RLE, 61 bytes.
static const unsigned char ic_round_24_action_description_data[] PROGMEM = {
  0x04, 0x0D, 0xF0, 0xE0, 0x65, 0x0D, 0xF9, 0x81, 0xDF, 0x74, 0xFA, 0x82, 0x1D, 0xF7, 0x3F, 0xA1,
  0x82, 0x1D, 0xF7, 0x2F, 0xA2, 0x82, 0x1D, 0xF7, 0x1F, 0xA3, 0x82, 0x1D, 0xF6, 0xFA, 0x03, 0x38,
  0x11, 0xDE, 0x80, 0xE0, 0xF0, 0x36, 0x03, 0xF9, 0x03, 0x60, 0x38, 0x0C, 0x4F, 0x03, 0x60, 0x3F,
  0x90, 0x36, 0x03, 0x80, 0xC0, 0xF0, 0xDF, 0xF8, 0x1D, 0x4D, 0xFD, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_description() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_description_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_disabled_by_default 24x24, 4-bit Alpha,  RLE, 86 bytes.
static const unsigned char ic_round_24_action_disabled_by_default_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xC4, 0xF8, 0x1D, 0x7E, 0xC8, 0x1E, 0x8D,
  0xF9, 0x82, 0x70, 0x2E, 0xA8, 0x2E, 0x20, 0x7F, 0x98, 0x90, 0xE2, 0x02, 0xEE, 0x20, 0x2E, 0xFA,
  0x86, 0xE2, 0x02, 0x20, 0x2E, 0xFC, 0x0E, 0x02, 0x20, 0x20, 0xEF, 0xD0, 0xE0, 0x22, 0x02, 0x0E,
  0xFC, 0x86, 0xE2, 0x02, 0x20, 0x2E, 0xFA, 0x89, 0x0E, 0x20, 0x2E, 0xE2, 0x02, 0xEF, 0x98, 0x27,
  0x02, 0xEA, 0x82, 0xE2, 0x08, 0xF9, 0x81, 0xD7, 0xEC, 0x81, 0xE8, 0xD8, 0x0C, 0x4F, 0x0D, 0xFF,
  0xA8, 0x1D, 0x4D, 0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_disabled_by_default() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_disabled_by_default_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_disabled_visible 24x24, 4-bit Alpha,  RLE, 172 bytes.
static const unsigned char ic_round_24_action_disabled_visible_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x50, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x20, 0x8A, 0x81, 0xC6,
  0x22, 0x81, 0x26, 0xCA, 0x08, 0x70, 0x8A, 0x07, 0x71, 0x06, 0xA0, 0x85, 0x04, 0xB0, 0xC0, 0x17,
  0x10, 0x4A, 0x04, 0x48, 0x5D, 0xF7, 0xCF, 0xC1, 0x71, 0x81, 0x6F, 0xD3, 0x87, 0x5F, 0xC0, 0x1C,
  0xFC, 0x17, 0x18, 0x1C, 0xF5, 0x28, 0x19, 0xF6, 0x28, 0x31, 0xCF, 0xC1, 0x78, 0x16, 0xF9, 0x28,
  0x1D, 0xF2, 0x38, 0x31, 0xCF, 0xC1, 0x68, 0x12, 0xFD, 0x20, 0xE9, 0x58, 0x21, 0xCF, 0xC7, 0x0A,
  0x0E, 0x28, 0x1E, 0xF1, 0x58, 0x11, 0x92, 0x71, 0x02, 0x28, 0x1D, 0xF3, 0x71, 0x86, 0x18, 0xCE,
  0xEC, 0x81, 0x38, 0x19, 0xF6, 0x70, 0x8F, 0x90, 0x82, 0x81, 0x5F, 0xD6, 0x0A, 0xB8, 0x28, 0x11,
  0x8B, 0x0A, 0x28, 0x1D, 0xF6, 0x40, 0x6B, 0x84, 0xB2, 0xDD, 0x2B, 0xB8, 0x16, 0x04, 0xA0, 0x43,
  0x0D, 0xB0, 0x80, 0x6A, 0x06, 0x08, 0xB0, 0xD2, 0x08, 0xA0, 0x72, 0x06, 0xB8, 0x4B, 0x2D, 0xD2,
  0xBB, 0x06, 0x30, 0x8A, 0x0B, 0x20, 0xAB, 0x82, 0x81, 0x18, 0xB0, 0xA5, 0x82, 0x4D, 0xF8, 0x20,
  0x8F, 0x90, 0x87, 0x18, 0x15, 0xA5, 0x28, 0x61, 0x8C, 0xEE, 0xC8, 0x13,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_disabled_visible() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 23, 21), Box(0, 0, 23, 23),
      ic_round_24_action_disabled_visible_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_display_settings 24x24, 4-bit Alpha,  RLE, 71 bytes.
static const unsigned char ic_round_24_action_display_settings_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDA, 0x77, 0x2C, 0x77, 0x2C, 0x74, 0x90, 0x73,
  0xC2, 0x80, 0x4B, 0x19, 0x0D, 0x0B, 0x2C, 0x28, 0x04, 0xB1, 0x90, 0xD0, 0xB2, 0xC7, 0x49, 0x07,
  0x3C, 0x30, 0x79, 0x74, 0xC2, 0x0B, 0x0D, 0x91, 0x80, 0x4B, 0x2C, 0x20, 0xB0, 0xD9, 0x18, 0x04,
  0xB2, 0xC3, 0x07, 0x97, 0x4C, 0x77, 0x2C, 0x77, 0x2A, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xA0,
  0xD0, 0x46, 0xF9, 0x75, 0x0B, 0xE0, 0xB6,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_display_settings() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_display_settings_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_dns 24x24, 4-bit Alpha,  RLE, 66 bytes.
static const unsigned char ic_round_24_action_dns_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0xA8, 0x2B, 0x11, 0xBF, 0xF0, 0x12, 0x01, 0xFF,
  0x01, 0x20, 0x1F, 0xF8, 0x2B, 0x11, 0xBF, 0xD0, 0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xF0, 0xD0, 0x48,
  0x0C, 0x00, 0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0xA8, 0x2B, 0x11, 0xBF, 0xF0, 0x12,
  0x01, 0xFF, 0x01, 0x20, 0x1F, 0xF8, 0x2B, 0x11, 0xBF, 0xD0, 0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xF0,
  0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_dns() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_dns_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_done_all 24x24, 4-bit Alpha,  RLE, 104 bytes.
static const unsigned char ic_round_24_action_done_all_data[] PROGMEM = {
  0x77, 0x18, 0x15, 0xD5, 0x38, 0x19, 0xD1, 0x77, 0x05, 0xA0, 0x52, 0x82, 0xAF, 0xE1, 0x76, 0x05,
  0xA0, 0x72, 0x82, 0xAF, 0xE3, 0x76, 0x05, 0xA0, 0x72, 0x82, 0xAF, 0xE3, 0x76, 0x05, 0xA0, 0x72,
  0x82, 0xAF, 0xE3, 0x76, 0x05, 0xA0, 0x72, 0x82, 0xAF, 0xE3, 0x50, 0x60, 0x43, 0x85, 0x17, 0x10,
  0x3E, 0x72, 0x82, 0xAF, 0xE3, 0x50, 0x1A, 0x05, 0x28, 0x46, 0xFD, 0x10, 0x12, 0x82, 0xAF, 0xE3,
  0x70, 0x7A, 0x05, 0x28, 0x2C, 0xFD, 0x12, 0x82, 0xAF, 0xE3, 0x72, 0x07, 0xA0, 0x52, 0x86, 0xCF,
  0xD2, 0xAF, 0xE3, 0x74, 0x07, 0xA0, 0x52, 0x0C, 0xB0, 0xE0, 0x37, 0x60, 0x7A, 0x02, 0x28, 0x2C,
  0xFE, 0x37, 0x71, 0x00, 0x54, 0x07, 0x02, 0x74,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_done_all() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 6, 23, 18), Box(0, 0, 23, 23),
      ic_round_24_action_done_all_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_done_outline 24x24, 4-bit Alpha,  RLE, 136 bytes.
static const unsigned char ic_round_24_action_done_outline_data[] PROGMEM = {
  0x77, 0x48, 0x28, 0xFD, 0x37, 0x75, 0x09, 0xB0, 0xE0, 0x37, 0x73, 0x85, 0x9F, 0xE7, 0xBF, 0xE7,
  0x72, 0x84, 0x9F, 0xE3, 0x05, 0xA0, 0x17, 0x78, 0x79, 0xFE, 0x30, 0x1D, 0xFB, 0x77, 0x87, 0x9F,
  0xE3, 0x01, 0xDF, 0xB7, 0x78, 0x79, 0xFE, 0x30, 0x1D, 0xFB, 0x58, 0x22, 0xBD, 0x65, 0x87, 0x9F,
  0xE3, 0x01, 0xDF, 0xB5, 0x02, 0x0D, 0xB0, 0x73, 0x87, 0x9F, 0xE3, 0x01, 0xDF, 0xB6, 0x82, 0xDF,
  0xC9, 0xA8, 0x91, 0x70, 0x9F, 0xE3, 0x01, 0xDF, 0xB6, 0x01, 0xA8, 0x15, 0x05, 0xA8, 0x7C, 0xFE,
  0x30, 0x1D, 0xFB, 0x71, 0x84, 0xCF, 0xC1, 0x05, 0xA8, 0x5E, 0x30, 0x1D, 0xFB, 0x72, 0x89, 0x41,
  0xDF, 0xC1, 0x05, 0xE3, 0x01, 0xDF, 0xB7, 0x48, 0x92, 0x1D, 0xFC, 0x10, 0x10, 0x1D, 0xFB, 0x76,
  0x89, 0x01, 0xDF, 0xC1, 0x01, 0xDF, 0xB7, 0x71, 0x86, 0x1D, 0xFC, 0x6D, 0xFB, 0x77, 0x30, 0x10,
  0xDB, 0x0B, 0x77, 0x58, 0x21, 0xCF, 0xA7, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_done_outline() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 3, 23, 20), Box(0, 0, 23, 23),
      ic_round_24_action_done_outline_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_done 24x24, 4-bit Alpha,  RLE, 56 bytes.
static const unsigned char ic_round_24_action_done_data[] PROGMEM = {
  0x77, 0x18, 0x14, 0xD5, 0x77, 0x04, 0xA0, 0x57, 0x60, 0x4A, 0x07, 0x76, 0x04, 0xA0, 0x77, 0x60,
  0x4A, 0x07, 0x76, 0x04, 0xA0, 0x75, 0x06, 0x03, 0x60, 0x4A, 0x07, 0x50, 0x1A, 0x04, 0x40, 0x4A,
  0x07, 0x70, 0x7A, 0x04, 0x20, 0x4A, 0x07, 0x72, 0x07, 0xA0, 0x04, 0xA0, 0x77, 0x40, 0x7C, 0x07,
  0x76, 0x07, 0xA0, 0x77, 0x71, 0x00, 0x57, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_done() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 6, 20, 18), Box(0, 0, 23, 23),
      ic_round_24_action_done_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_donut_large 24x24, 4-bit Alpha,  RLE, 136 bytes.
static const unsigned char ic_round_24_action_donut_large_data[] PROGMEM = {
  0x68, 0x15, 0x93, 0x28, 0x13, 0x94, 0x73, 0x04, 0x0D, 0xA0, 0xD2, 0x0D, 0xA0, 0xD0, 0x47, 0x08,
  0xC0, 0xC2, 0x0C, 0xC0, 0x75, 0x08, 0xB8, 0x1E, 0x81, 0x28, 0x11, 0x7E, 0xB0, 0x73, 0x04, 0xB0,
  0xB0, 0x16, 0x01, 0x0A, 0xB0, 0x42, 0x0D, 0xA0, 0xA7, 0x30, 0xAA, 0x81, 0xD0, 0x5A, 0x0E, 0x01,
  0x73, 0x01, 0x0E, 0xA0, 0x40, 0xAA, 0x07, 0x75, 0x07, 0xA0, 0x80, 0xDA, 0x03, 0x75, 0x83, 0x1C,
  0xD3, 0xEA, 0x01, 0x77, 0x20, 0xEA, 0x01, 0x77, 0x20, 0xDA, 0x03, 0x76, 0x82, 0xCE, 0x3A, 0xA0,
  0x77, 0x50, 0x7A, 0x09, 0x05, 0xA0, 0xE0, 0x17, 0x30, 0x10, 0xEA, 0x81, 0x40, 0xDA, 0x0A, 0x73,
  0x0A, 0xA0, 0xD2, 0x04, 0xB0, 0xB0, 0x17, 0x0A, 0xB0, 0x43, 0x08, 0xB8, 0x1E, 0x81, 0x28, 0x11,
  0x7E, 0xB0, 0x75, 0x08, 0xC0, 0xC2, 0x0C, 0xC0, 0x77, 0x04, 0x0D, 0xA0, 0xD2, 0x0D, 0xA0, 0xD0,
  0x47, 0x38, 0x15, 0x93, 0x28, 0x13, 0x94, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_donut_large() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_donut_large_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_donut_small 24x24, 4-bit Alpha,  RLE, 94 bytes.
static const unsigned char ic_round_24_action_donut_small_data[] PROGMEM = {
  0x68, 0x16, 0xA8, 0x28, 0x18, 0xA6, 0x73, 0x05, 0x0E, 0xB2, 0x0E, 0xA0, 0xE0, 0x67, 0x09, 0xD2,
  0xD0, 0x95, 0x09, 0xE2, 0xE0, 0x93, 0x05, 0xF2, 0xF0, 0x52, 0x0D, 0xF2, 0xF8, 0x1E, 0x05, 0xF9,
  0x2F, 0x90, 0x60, 0xAF, 0x92, 0xF9, 0x0B, 0x0D, 0xF9, 0x20, 0xBF, 0x08, 0x0E, 0xF9, 0x74, 0x0E,
  0xF9, 0x74, 0x0D, 0xF9, 0x20, 0xBF, 0x09, 0x0A, 0xF9, 0x2F, 0x90, 0xB0, 0x5F, 0x92, 0xF9, 0x81,
  0x60, 0xDF, 0x2F, 0x0E, 0x20, 0x5F, 0x2F, 0x06, 0x30, 0x9E, 0x2E, 0x09, 0x50, 0x9D, 0x2D, 0x09,
  0x70, 0x50, 0xEB, 0x20, 0xEA, 0x0E, 0x06, 0x73, 0x81, 0x6A, 0x82, 0x81, 0x8A, 0x66,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_donut_small() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_donut_small_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_drag_indicator 24x24, 4-bit Alpha,  RLE, 71 bytes.
static const unsigned char ic_round_24_action_drag_indicator_data[] PROGMEM = {
  0x82, 0x4D, 0xD4, 0x28, 0x34, 0xDD, 0x4D, 0xA0, 0xD2, 0x0D, 0xA0, 0x0D, 0xA0, 0xD2, 0x0D, 0xA8,
  0x3D, 0x4D, 0xD4, 0x28, 0x24, 0xDD, 0x47, 0x76, 0x82, 0x4D, 0xD4, 0x28, 0x34, 0xDD, 0x4D, 0xA0,
  0xD2, 0x0D, 0xA0, 0x0D, 0xA0, 0xD2, 0x0D, 0xA8, 0x3D, 0x4D, 0xD4, 0x28, 0x24, 0xDD, 0x47, 0x76,
  0x82, 0x4D, 0xD4, 0x28, 0x34, 0xDD, 0x4D, 0xA0, 0xD2, 0x0D, 0xA0, 0x0D, 0xA0, 0xD2, 0x0D, 0xA8,
  0x3D, 0x4D, 0xD4, 0x28, 0x24, 0xDD, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_drag_indicator() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(7, 4, 16, 19), Box(0, 0, 23, 23),
      ic_round_24_action_drag_indicator_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_dynamic_form 24x24, 4-bit Alpha,  RLE, 76 bytes.
static const unsigned char ic_round_24_action_dynamic_form_data[] PROGMEM = {
  0x04, 0x0D, 0xFA, 0x20, 0xED, 0x09, 0x0D, 0xFB, 0x2E, 0x06, 0xB0, 0xDF, 0x2D, 0x0E, 0x1A, 0x81,
  0xD0, 0xDE, 0x2D, 0x09, 0x1B, 0x0D, 0xF2, 0xD8, 0x13, 0x0D, 0xFB, 0x2E, 0x81, 0x94, 0xDF, 0xA2,
  0x0E, 0xD0, 0x57, 0x71, 0xB0, 0xD7, 0x72, 0xB8, 0x26, 0x04, 0xDF, 0xC2, 0xA0, 0xE2, 0x0D, 0xFD,
  0x2A, 0x07, 0x2B, 0x0D, 0xFA, 0x29, 0x0E, 0x01, 0x2A, 0x81, 0xD0, 0xDF, 0x92, 0x90, 0x93, 0xB0,
  0xDF, 0xA2, 0x90, 0x23, 0x0D, 0xFD, 0x20, 0x14, 0x04, 0x0D, 0xFC, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_dynamic_form() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_dynamic_form_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_eco 24x24, 4-bit Alpha,  RLE, 80 bytes.
static const unsigned char ic_round_24_action_eco_data[] PROGMEM = {
  0x72, 0x85, 0x14, 0x68, 0xAC, 0xA6, 0x81, 0x48, 0xCE, 0x0C, 0x38, 0x11, 0x7E, 0xFA, 0x0A, 0x20,
  0x40, 0xEF, 0xC8, 0x18, 0x05, 0xFE, 0x81, 0x61, 0xEF, 0xE0, 0x40, 0x8F, 0x0B, 0xE0, 0x10, 0xDD,
  0x81, 0xE5, 0xED, 0x0C, 0x1D, 0x81, 0xD2, 0xDE, 0x08, 0x1C, 0x81, 0xC1, 0xAF, 0x81, 0x40, 0xDA,
  0x81, 0xE1, 0x4F, 0x0E, 0x20, 0x9A, 0x81, 0x50, 0xBF, 0x07, 0x28, 0x32, 0xFB, 0x03, 0xF0, 0xE0,
  0x13, 0x82, 0x62, 0x08, 0xF0, 0x47, 0x0C, 0xD0, 0xE0, 0x47, 0x10, 0x80, 0xDA, 0x81, 0xC7, 0x15,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_eco() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 4, 19, 19), Box(0, 0, 23, 23),
      ic_round_24_action_eco_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_edit_calendar 24x24, 4-bit Alpha,  RLE, 77 bytes.
static const unsigned char ic_round_24_action_edit_calendar_data[] PROGMEM = {
  0x30, 0x0B, 0x71, 0x00, 0xB7, 0x1A, 0x71, 0xA5, 0x04, 0x0D, 0xFF, 0x0D, 0x04, 0x20, 0xDF, 0xFA,
  0x0D, 0x2F, 0xFC, 0x2F, 0xFC, 0x2F, 0xFC, 0x2F, 0xFC, 0x2A, 0x77, 0xA2, 0xA7, 0x7A, 0x2A, 0x77,
  0x4A, 0x77, 0x4A, 0x77, 0x18, 0x19, 0xF7, 0xA7, 0x70, 0x20, 0x5C, 0x76, 0x83, 0x9E, 0x45, 0x9A,
  0x75, 0x09, 0xA0, 0xE0, 0x21, 0xA7, 0x40, 0x9B, 0x09, 0x2A, 0x73, 0x09, 0xB0, 0x93, 0x0D, 0xF9,
  0x20, 0x8B, 0x09, 0x40, 0x40, 0xDF, 0x2B, 0x09, 0x77, 0x28, 0x1E, 0xF8, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_edit_calendar() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_edit_calendar_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_edit_off 24x24, 4-bit Alpha,  RLE, 122 bytes.
static const unsigned char ic_round_24_action_edit_off_data[] PROGMEM = {
  0x10, 0x90, 0x67, 0x58, 0x14, 0xD8, 0x20, 0x1A, 0x07, 0x73, 0x04, 0xB0, 0x82, 0x05, 0xA0, 0x77,
  0x20, 0x7C, 0x08, 0x20, 0x5A, 0x07, 0x68, 0x24, 0x50, 0x7B, 0x0D, 0x30, 0x5A, 0x07, 0x40, 0x4A,
  0x81, 0x50, 0x7A, 0x04, 0x40, 0x5A, 0x07, 0x20, 0x3C, 0x82, 0x50, 0x74, 0x60, 0x5A, 0x07, 0x20,
  0xAC, 0x05, 0x72, 0x05, 0xA0, 0x72, 0x0A, 0xB0, 0x47, 0x30, 0x8A, 0x07, 0x28, 0x1A, 0xF4, 0x73,
  0x04, 0xC0, 0x72, 0x03, 0x73, 0x04, 0xE0, 0x77, 0x40, 0x4F, 0x90, 0x77, 0x20, 0x4E, 0x0E, 0x08,
  0xA0, 0x77, 0x04, 0xE8, 0x2E, 0x40, 0x5A, 0x07, 0x60, 0xED, 0x0E, 0x04, 0x30, 0x5A, 0x07, 0x5D,
  0x0E, 0x04, 0x50, 0x5A, 0x07, 0x4C, 0x0E, 0x04, 0x70, 0x5A, 0x07, 0x30, 0xEA, 0x0E, 0x04, 0x72,
  0x05, 0xA0, 0x67, 0x73, 0x81, 0x5F, 0x97, 0x74, 0x01, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_edit_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 20, 22), Box(0, 0, 23, 23),
      ic_round_24_action_edit_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_eject 24x24, 4-bit Alpha,  RLE, 45 bytes.
static const unsigned char ic_round_24_action_eject_data[] PROGMEM = {
  0x60, 0x01, 0x74, 0x82, 0x1D, 0xD1, 0x73, 0x0A, 0xA0, 0xA7, 0x20, 0x5C, 0x05, 0x70, 0x10, 0xEC,
  0x0E, 0x01, 0x60, 0xAE, 0x0A, 0x50, 0x5F, 0x90, 0x53, 0x01, 0x0E, 0xF9, 0x0E, 0x01, 0x20, 0x9F,
  0xB0, 0x92, 0x08, 0xFB, 0x08, 0x77, 0x77, 0x10, 0xBF, 0xD0, 0x0B, 0xFD, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_eject() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 5, 18, 18), Box(0, 0, 23, 23),
      ic_round_24_action_eject_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_euro_symbol 24x24, 4-bit Alpha,  RLE, 89 bytes.
static const unsigned char ic_round_24_action_euro_symbol_data[] PROGMEM = {
  0x71, 0x81, 0x49, 0xDA, 0x81, 0xD9, 0x47, 0x10, 0x20, 0xBF, 0x90, 0xB6, 0x03, 0x0E, 0xB8, 0x2B,
  0x88, 0xBB, 0x04, 0x40, 0x20, 0xEA, 0x08, 0x01, 0x48, 0x11, 0x78, 0x50, 0xBA, 0x05, 0x76, 0x03,
  0xA0, 0x97, 0x40, 0xBF, 0xB0, 0xB6, 0x0B, 0xFB, 0x0B, 0x72, 0xA0, 0x87, 0x71, 0xA0, 0x87, 0x50,
  0xBF, 0xB0, 0xB6, 0x0B, 0xFB, 0x0B, 0x72, 0x03, 0xA0, 0x97, 0x71, 0x0B, 0xA0, 0x57, 0x70, 0x20,
  0xEA, 0x08, 0x01, 0x48, 0x11, 0x78, 0x60, 0x30, 0xEB, 0x82, 0xB8, 0x8B, 0xB0, 0x46, 0x02, 0x0B,
  0xF9, 0x0B, 0x72, 0x81, 0x49, 0xDA, 0x81, 0xD9, 0x42,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_euro_symbol() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_euro_symbol_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_event 24x24, 4-bit Alpha,  RLE, 51 bytes.
static const unsigned char ic_round_24_action_event_data[] PROGMEM = {
  0x30, 0x0B, 0x71, 0x00, 0xB6, 0xA7, 0x1A, 0x30, 0x40, 0xDF, 0xF8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD8,
  0x0E, 0x4F, 0x77, 0xC7, 0x7C, 0x77, 0xC7, 0x7C, 0x70, 0xBB, 0x0B, 0x2C, 0x7D, 0x2C, 0x7D, 0x2C,
  0x7D, 0x2C, 0x70, 0xBB, 0x0B, 0x2C, 0x77, 0xC0, 0x37, 0x50, 0x3A, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D,
  0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_event() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_event_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_event_repeat 24x24, 4-bit Alpha,  RLE, 96 bytes.
static const unsigned char ic_round_24_action_event_repeat_data[] PROGMEM = {
  0x30, 0x0B, 0x71, 0x00, 0xB7, 0x2A, 0x71, 0xA6, 0x04, 0x0D, 0xFF, 0x0D, 0x04, 0x30, 0xDF, 0xFA,
  0x0D, 0x3F, 0xFC, 0x3F, 0xFC, 0x3F, 0xFC, 0x3F, 0xFC, 0x3A, 0x77, 0xA3, 0xA7, 0x7A, 0x3A, 0x77,
  0x5A, 0x77, 0x5A, 0x72, 0x86, 0xC5, 0x4B, 0xEE, 0xB4, 0x2A, 0x72, 0x98, 0x6D, 0xFD, 0x99, 0xDF,
  0x81, 0xA7, 0x2A, 0x0E, 0x05, 0x38, 0x19, 0xF4, 0xA7, 0x20, 0xBA, 0x0C, 0x40, 0xD0, 0xBA, 0x77,
  0x30, 0x90, 0xEA, 0x77, 0x38, 0x19, 0xED, 0xF9, 0x20, 0x70, 0xC6, 0x82, 0xDB, 0x4D, 0xF2, 0x81,
  0x4F, 0x94, 0x81, 0x9F, 0x47, 0x58, 0x67, 0xFD, 0x89, 0xDF, 0x87, 0x78, 0x44, 0xBE, 0xEB, 0x42,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_event_repeat() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 23, 23), Box(0, 0, 23, 23),
      ic_round_24_action_event_repeat_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_event_seat 24x24, 4-bit Alpha,  RLE, 62 bytes.
static const unsigned char ic_round_24_action_event_seat_data[] PROGMEM = {
  0x50, 0x40, 0xDE, 0x0D, 0x04, 0x73, 0x0D, 0xF9, 0x0D, 0x73, 0xFB, 0x73, 0xFB, 0x73, 0xFB, 0x73,
  0xFB, 0x73, 0xFB, 0x58, 0x1B, 0xFB, 0x2F, 0xB2, 0x81, 0xBF, 0xBB, 0x2F, 0xB2, 0xB8, 0x1B, 0xFB,
  0x2F, 0xB2, 0x81, 0xBF, 0xB8, 0x0C, 0x60, 0x04, 0x0D, 0xFD, 0x0D, 0x04, 0x40, 0xDF, 0xF0, 0xD4,
  0xFF, 0xA4, 0xB7, 0x3B, 0x4B, 0x73, 0xB4, 0x81, 0x8E, 0x87, 0x38, 0x18, 0xE8, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_event_seat() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_event_seat_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_exit_to_app 24x24, 4-bit Alpha,  RLE, 75 bytes.
static const unsigned char ic_round_24_action_exit_to_app_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0xA0, 0x37, 0x50, 0x3C, 0x77, 0xC5, 0x81, 0x17,
  0x16, 0xA0, 0x0B, 0x58, 0x26, 0xFD, 0x15, 0xA7, 0x18, 0x2B, 0xFD, 0x14, 0xA7, 0x28, 0x2B, 0xFD,
  0x13, 0xA0, 0xBF, 0xC0, 0xD3, 0xA0, 0xBF, 0xC0, 0xD3, 0xA7, 0x28, 0x2B, 0xFD, 0x13, 0xA7, 0x18,
  0x2B, 0xFD, 0x14, 0xA0, 0x0B, 0x58, 0x26, 0xFD, 0x15, 0xC5, 0x81, 0x17, 0x16, 0xC7, 0x7C, 0x03,
  0x75, 0x03, 0xA0, 0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xF0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_exit_to_app() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_exit_to_app_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_expand 24x24, 4-bit Alpha,  RLE, 49 bytes.
static const unsigned char ic_round_24_action_expand_data[] PROGMEM = {
  0x0B, 0xFF, 0x00, 0xBF, 0xF0, 0xB7, 0x77, 0x20, 0x07, 0x76, 0x07, 0xA0, 0x77, 0x40, 0x7C, 0x07,
  0x72, 0x02, 0xE0, 0x27, 0x4A, 0x77, 0xA7, 0x7A, 0x77, 0xA7, 0x7A, 0x77, 0xA7, 0x40, 0x2E, 0x02,
  0x72, 0x07, 0xC0, 0x77, 0x40, 0x7A, 0x07, 0x76, 0x00, 0x77, 0x77, 0x20, 0xBF, 0xF0, 0x0B, 0xFF,
  0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_expand() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_expand_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_explore_off 24x24, 4-bit Alpha,  RLE, 143 bytes.
static const unsigned char ic_round_24_action_explore_off_data[] PROGMEM = {
  0x68, 0x65, 0xAD, 0xFE, 0xD9, 0x57, 0x30, 0x30, 0xDF, 0x90, 0xD0, 0x44, 0x81, 0x4E, 0x72, 0x0A,
  0xFB, 0x08, 0x30, 0x3A, 0x07, 0x20, 0xAF, 0xB0, 0x83, 0x08, 0xA0, 0x72, 0x0A, 0xE0, 0xA0, 0x7A,
  0x04, 0x20, 0xDB, 0x07, 0x20, 0xAB, 0x82, 0x92, 0x0A, 0xA8, 0x1D, 0x05, 0xD0, 0x72, 0x81, 0x98,
  0x12, 0x02, 0xC0, 0x50, 0xAE, 0x07, 0x60, 0x9C, 0x09, 0x0D, 0xF0, 0x74, 0x01, 0xD0, 0xD0, 0xED,
  0x0E, 0xA0, 0x73, 0x08, 0xD0, 0x0E, 0xD0, 0x80, 0x5A, 0x07, 0x20, 0x9D, 0x0E, 0x0D, 0xD8, 0x11,
  0x05, 0xA0, 0x72, 0x0A, 0xC0, 0xD0, 0xAC, 0x09, 0x30, 0x5A, 0x07, 0x20, 0xAB, 0x0A, 0x05, 0xC0,
  0x22, 0x81, 0x18, 0xEA, 0x07, 0x20, 0xAA, 0x81, 0x50, 0xDA, 0x82, 0xA0, 0x29, 0xE0, 0x72, 0x0A,
  0x0D, 0x20, 0x5A, 0x07, 0x0A, 0xFA, 0x07, 0x20, 0x33, 0x09, 0xFE, 0x07, 0x60, 0x9F, 0xE0, 0x76,
  0x05, 0x0D, 0xF9, 0x82, 0xD8, 0xFE, 0x71, 0x86, 0x5A, 0xDE, 0xED, 0x95, 0x20, 0x30, 0x42,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_explore_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_explore_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_explore 24x24, 4-bit Alpha,  RLE, 120 bytes.
static const unsigned char ic_round_24_action_explore_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFD, 0x0A, 0x07, 0xA0, 0x42, 0x0D, 0xFB, 0x82, 0x92, 0x0A, 0xA8, 0x1D,
  0x05, 0xF9, 0x81, 0xE8, 0x12, 0x02, 0xC0, 0x50, 0x9E, 0x81, 0xE7, 0x14, 0x09, 0xC0, 0x90, 0xDE,
  0x07, 0x50, 0x1D, 0x0D, 0x0E, 0xD8, 0x3E, 0x10, 0xDD, 0x20, 0x8D, 0x00, 0xED, 0x08, 0x28, 0x3D,
  0xD0, 0x1E, 0xD0, 0xE0, 0xDD, 0x01, 0x50, 0x7E, 0x0D, 0x09, 0xC0, 0x94, 0x81, 0x17, 0xEE, 0x09,
  0x05, 0xC0, 0x22, 0x81, 0x18, 0xEF, 0x98, 0x15, 0x0D, 0xA8, 0x2A, 0x02, 0x9F, 0xB0, 0xD2, 0x04,
  0xA0, 0x70, 0xAF, 0xD0, 0x43, 0x08, 0xFF, 0x08, 0x50, 0x8F, 0xD0, 0x87, 0x04, 0x0D, 0xF9, 0x0D,
  0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_explore() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_explore_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_extension_off 24x24, 4-bit Alpha,  RLE, 118 bytes.
static const unsigned char ic_round_24_action_extension_off_data[] PROGMEM = {
  0x72, 0x81, 0x37, 0x37, 0x74, 0x06, 0xB0, 0x67, 0x30, 0x90, 0x65, 0x0D, 0xB0, 0xD7, 0x20, 0x1A,
  0x07, 0x20, 0xAF, 0xB0, 0xD0, 0x44, 0x05, 0xA0, 0x72, 0x0A, 0xFB, 0x0D, 0x5B, 0x07, 0x20, 0xAF,
  0xB5, 0xC0, 0x72, 0x0A, 0xFA, 0x5D, 0x07, 0x20, 0xAF, 0x95, 0x0D, 0xD0, 0x72, 0x0A, 0xF6, 0x02,
  0x0C, 0xC0, 0x72, 0x0A, 0xE0, 0xD0, 0x65, 0x03, 0xD0, 0x72, 0x0A, 0xF0, 0x35, 0xE0, 0x72, 0x0A,
  0xE0, 0x64, 0x03, 0xF0, 0x72, 0x0A, 0xD0, 0x33, 0x02, 0x0C, 0xF9, 0x07, 0x20, 0xAA, 0x0D, 0x06,
  0x30, 0xDF, 0xC0, 0x72, 0x0A, 0x95, 0xFE, 0x07, 0x20, 0xA5, 0xFF, 0x07, 0x7E, 0x83, 0xC3, 0x03,
  0xCC, 0x07, 0x60, 0xDD, 0x02, 0x30, 0x2D, 0x07, 0x50, 0x40, 0xDB, 0x0D, 0x50, 0xDD, 0x06, 0x77,
  0x58, 0x15, 0xF9, 0x77, 0x60, 0x13,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_extension_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_extension_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_extension 24x24, 4-bit Alpha,  RLE, 86 bytes.
static const unsigned char ic_round_24_action_extension_data[] PROGMEM = {
  0x68, 0x31, 0xBE, 0xB1, 0x77, 0x20, 0xBB, 0x0B, 0x77, 0x2D, 0x77, 0x2D, 0x73, 0x04, 0x0D, 0xFE,
  0x0D, 0x04, 0x40, 0xDF, 0xF9, 0x0D, 0x4F, 0xFB, 0x4F, 0xFB, 0x4F, 0xFB, 0x40, 0xB0, 0xCF, 0xF9,
  0x60, 0x10, 0xBF, 0xF9, 0x0B, 0x01, 0x30, 0x1F, 0xFA, 0x0B, 0x40, 0xDF, 0xF9, 0x0E, 0x30, 0x1F,
  0xFA, 0x0B, 0x20, 0x10, 0xBF, 0xF9, 0x82, 0xB1, 0xBC, 0xFF, 0x94, 0xF9, 0x0D, 0xF9, 0x4E, 0x83,
  0xB1, 0x01, 0xBE, 0x4E, 0x01, 0x30, 0x1E, 0x40, 0xDC, 0x0C, 0x50, 0xCC, 0x0D, 0x40, 0x40, 0xDB,
  0x0C, 0x50, 0xCB, 0x0D, 0x04, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_extension() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 1, 22, 21), Box(0, 0, 23, 23),
      ic_round_24_action_extension_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_face 24x24, 4-bit Alpha,  RLE, 136 bytes.
static const unsigned char ic_round_24_action_face_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xD0, 0xB0, 0xEF, 0xA0, 0x42, 0x0D, 0xD8, 0x11, 0x2D, 0xF9, 0x81, 0xD0,
  0x5D, 0x06, 0x20, 0x10, 0x9F, 0x90, 0x50, 0x9C, 0x08, 0x58, 0x90, 0x17, 0xBD, 0xFD, 0xDF, 0x9D,
  0xB0, 0x67, 0x58, 0x52, 0xFD, 0xEF, 0x92, 0x20, 0x01, 0x40, 0x01, 0x49, 0x00, 0xE9, 0x38, 0x21,
  0xEE, 0x12, 0x82, 0x1E, 0xE1, 0x39, 0x82, 0xED, 0xF2, 0x28, 0x21, 0xEE, 0x12, 0x82, 0x1E, 0xE1,
  0x28, 0x42, 0xFD, 0x9F, 0x63, 0x00, 0x14, 0x00, 0x13, 0x84, 0x6F, 0x95, 0xFC, 0x77, 0x85, 0xCF,
  0x50, 0xDF, 0x67, 0x58, 0x16, 0xFD, 0x20, 0x4A, 0x04, 0x73, 0x04, 0xA0, 0x43, 0x08, 0xA0, 0x67,
  0x10, 0x6A, 0x08, 0x50, 0x8A, 0x81, 0xC6, 0x22, 0x81, 0x26, 0xCA, 0x08, 0x70, 0x40, 0xDF, 0x90,
  0xD0, 0x47, 0x38, 0x65, 0x9D, 0xEE, 0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_face() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_face_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_face_unlock 24x24, 4-bit Alpha,  RLE, 156 bytes.
static const unsigned char ic_round_24_action_face_unlock_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xC8, 0x4E, 0x11,
  0x36, 0xDA, 0x08, 0x50, 0x8A, 0x08, 0xB0, 0xB4, 0x07, 0xA0, 0x83, 0x04, 0xA8, 0x64, 0x9F, 0xBE,
  0xFC, 0x23, 0x04, 0xA0, 0x42, 0x82, 0xDF, 0x64, 0xA8, 0x11, 0x2D, 0xA8, 0x92, 0xA4, 0x20, 0x8F,
  0xD0, 0x5F, 0xD4, 0xA0, 0x62, 0x01, 0x09, 0xF9, 0x82, 0x59, 0xFD, 0xA0, 0x85, 0x89, 0x01, 0x7B,
  0xDF, 0xDD, 0xF9, 0xDB, 0x06, 0x75, 0x85, 0x2F, 0xDE, 0xF9, 0x22, 0x00, 0x14, 0x00, 0x14, 0x90,
  0x0E, 0x93, 0x82, 0x1E, 0xE1, 0x28, 0x21, 0xEE, 0x13, 0x98, 0x2E, 0xDF, 0x22, 0x82, 0x1E, 0xE1,
  0x28, 0x21, 0xEE, 0x12, 0x84, 0x2F, 0xD9, 0xF6, 0x30, 0x01, 0x40, 0x01, 0x38, 0x46, 0xF9, 0x5F,
  0xC7, 0x78, 0x5C, 0xF5, 0x0D, 0xF6, 0x75, 0x81, 0x6F, 0xD2, 0x04, 0xA0, 0x47, 0x30, 0x4A, 0x04,
  0x30, 0x8A, 0x06, 0x71, 0x06, 0xA0, 0x85, 0x08, 0xA8, 0x1C, 0x62, 0x28, 0x12, 0x6C, 0xA0, 0x87,
  0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_face_unlock() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_face_unlock_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_fact_check 24x24, 4-bit Alpha,  RLE, 66 bytes.
static const unsigned char ic_round_24_action_fact_check_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xD8, 0x0C, 0x7F, 0x03, 0x30, 0x3F, 0xF9, 0x03,
  0x30, 0x3F, 0xFF, 0xE0, 0x90, 0xAF, 0xFB, 0x81, 0x70, 0x1E, 0x03, 0x30, 0x3A, 0x82, 0xB4, 0xC7,
  0x20, 0xAE, 0x03, 0x30, 0x3A, 0x08, 0x40, 0xAF, 0xF9, 0x05, 0x20, 0xAF, 0xFB, 0x08, 0x0B, 0xFA,
  0x03, 0x30, 0x3F, 0xF9, 0x03, 0x30, 0x38, 0x0E, 0x0F, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xA0,
  0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_fact_check() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_fact_check_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_favorite_border 24x24, 4-bit Alpha,  RLE, 121 bytes.
static const unsigned char ic_round_24_action_favorite_border_data[] PROGMEM = {
  0x28, 0x51, 0x9D, 0xDD, 0x82, 0x28, 0x52, 0x8D, 0xDD, 0x71, 0x30, 0x40, 0xED, 0x81, 0xE5, 0x6E,
  0x89, 0x1E, 0x40, 0x2E, 0xFA, 0x30, 0x29, 0xC8, 0x91, 0x92, 0x03, 0xAF, 0xE2, 0x9F, 0xA5, 0x07,
  0xA0, 0x75, 0x84, 0xAF, 0x9D, 0xF3, 0x60, 0x05, 0x68, 0x13, 0xFD, 0xA7, 0x72, 0xA8, 0x1D, 0xF2,
  0x77, 0x84, 0x2F, 0xD9, 0xF7, 0x77, 0x85, 0x7F, 0x93, 0xFE, 0x17, 0x58, 0x61, 0xEF, 0x30, 0xAF,
  0xB7, 0x58, 0x1B, 0xFA, 0x28, 0x21, 0xDF, 0x97, 0x38, 0x29, 0xFD, 0x13, 0x82, 0x3E, 0xF8, 0x71,
  0x82, 0x8F, 0xE2, 0x50, 0x4A, 0x09, 0x68, 0x29, 0xFE, 0x47, 0x04, 0xA0, 0x94, 0x82, 0x9F, 0xE4,
  0x72, 0x82, 0x3E, 0xFA, 0x28, 0x2A, 0xFE, 0x37, 0x48, 0x63, 0xEF, 0xBB, 0xFE, 0x37, 0x60, 0x20,
  0xDA, 0x0D, 0x02, 0x77, 0x18, 0x21, 0x88, 0x17, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_favorite_border() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_favorite_border_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_favorite 24x24, 4-bit Alpha,  RLE, 88 bytes.
static const unsigned char ic_round_24_action_favorite_data[] PROGMEM = {
  0x28, 0x51, 0x7D, 0xDD, 0x82, 0x28, 0x52, 0x8D, 0xDD, 0x91, 0x30, 0x40, 0xEE, 0x81, 0x65, 0xED,
  0x83, 0xE4, 0x02, 0xEF, 0xFA, 0x81, 0xE2, 0x9F, 0xFC, 0x09, 0x0D, 0xFF, 0xC0, 0xDF, 0xFE, 0x0D,
  0xFF, 0xC0, 0xD0, 0x9F, 0xFC, 0x09, 0x03, 0xFF, 0xC8, 0x13, 0x0A, 0xFF, 0xA0, 0xA2, 0x01, 0x0D,
  0xFF, 0x0D, 0x01, 0x30, 0x30, 0xEF, 0xD0, 0xE0, 0x35, 0x04, 0x0E, 0xFC, 0x04, 0x70, 0x40, 0xEF,
  0xA0, 0x47, 0x20, 0x30, 0xEE, 0x0E, 0x03, 0x74, 0x03, 0x0E, 0xC0, 0xE0, 0x37, 0x60, 0x20, 0xDA,
  0x0D, 0x02, 0x77, 0x18, 0x21, 0x88, 0x17, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_favorite() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_favorite_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_fax 24x24, 4-bit Alpha,  RLE, 75 bytes.
static const unsigned char ic_round_24_action_fax_data[] PROGMEM = {
  0x60, 0x40, 0xDE, 0x0D, 0x04, 0x73, 0x0D, 0xF9, 0x0D, 0x73, 0xA6, 0xA7, 0x3A, 0x6A, 0x48, 0x31,
  0xBE, 0xB1, 0x1A, 0x6A, 0x40, 0xBB, 0x0B, 0x1F, 0xC0, 0xD0, 0x81, 0xD1, 0xFE, 0x08, 0xD1, 0xFE,
  0x0D, 0xD1, 0xA4, 0x98, 0x33, 0x3F, 0x33, 0xF1, 0xA4, 0x98, 0x33, 0x3F, 0x33, 0xF1, 0xA4, 0xFE,
  0x1A, 0x49, 0x83, 0x33, 0xF3, 0x3F, 0x1A, 0x49, 0x83, 0x33, 0xF3, 0x3F, 0x1F, 0xFD, 0x1F, 0xE0,
  0xD0, 0xBB, 0x0B, 0x1F, 0xD8, 0x5D, 0x41, 0xBE, 0xB1, 0x77, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_fax() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_fax_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_feedback 24x24, 4-bit Alpha,  RLE, 44 bytes.
static const unsigned char ic_round_24_action_feedback_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xD8, 0x0D, 0x5F, 0x00, 0x3F, 0xFC, 0x2F, 0xFC,
  0x2F, 0xFC, 0x00, 0x38, 0x0E, 0x6F, 0x2F, 0xFC, 0x28, 0x09, 0x80, 0xF0, 0xDF, 0xFC, 0x0D, 0x04,
  0xB0, 0x77, 0x72, 0xA0, 0x77, 0x73, 0x90, 0x77, 0x74, 0x07, 0x77, 0x50,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_feedback() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_feedback_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_file_present 24x24, 4-bit Alpha,  RLE, 87 bytes.
static const unsigned char ic_round_24_action_file_present_data[] PROGMEM = {
  0x04, 0x0D, 0xF0, 0xE0, 0x65, 0x0D, 0xFB, 0x07, 0x4F, 0xB8, 0x17, 0xF7, 0x3F, 0xB1, 0x81, 0x7F,
  0x72, 0xFB, 0x28, 0x17, 0xF7, 0x1C, 0x85, 0xD4, 0x04, 0xDF, 0x32, 0x81, 0x7F, 0x6C, 0x04, 0x30,
  0x4E, 0x0E, 0xC2, 0x0D, 0x2F, 0xC2, 0x92, 0xFC, 0x29, 0x29, 0x00, 0x3F, 0x92, 0x92, 0x92, 0xF9,
  0x29, 0x29, 0x2F, 0x92, 0x90, 0x03, 0x92, 0xF9, 0x81, 0x10, 0xDA, 0x81, 0xD0, 0x1F, 0x98, 0x66,
  0x04, 0xDD, 0x40, 0x5F, 0x90, 0xD0, 0x14, 0x01, 0x0D, 0xFA, 0x84, 0xD5, 0x11, 0x5D, 0xFF, 0xF0,
  0xDF, 0xF8, 0x1D, 0x4D, 0xFD, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_file_present() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_file_present_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_filter_alt_off 24x24, 4-bit Alpha,  RLE, 99 bytes.
static const unsigned char ic_round_24_action_filter_alt_off_data[] PROGMEM = {
  0x10, 0x90, 0x67, 0x73, 0x01, 0xA0, 0x72, 0x0A, 0xFC, 0x0B, 0x20, 0x5A, 0x07, 0x20, 0xAF, 0xB0,
  0xC3, 0x05, 0xA0, 0x72, 0x0A, 0xF9, 0x0E, 0x02, 0x40, 0x5A, 0x07, 0x20, 0xAF, 0x04, 0x60, 0x6A,
  0x07, 0x20, 0xAD, 0x08, 0x71, 0x06, 0xA0, 0x72, 0x0A, 0xB0, 0xB7, 0x30, 0x6A, 0x07, 0x28, 0x2A,
  0xFD, 0x17, 0x40, 0x7A, 0x07, 0x20, 0x90, 0x37, 0x60, 0x7A, 0x07, 0x77, 0x3B, 0x07, 0x77, 0x2C,
  0x07, 0x77, 0x1D, 0x07, 0x77, 0xE0, 0x77, 0x6C, 0x05, 0xA0, 0x77, 0x50, 0xDA, 0x81, 0xD0, 0x5A,
  0x07, 0x74, 0x82, 0x4D, 0xD4, 0x20, 0x5A, 0x07, 0x77, 0x30, 0x5A, 0x06, 0x77, 0x38, 0x15, 0xF9,
  0x77, 0x40, 0x11,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_filter_alt_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 20, 22), Box(0, 0, 23, 23),
      ic_round_24_action_filter_alt_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_filter_alt 24x24, 4-bit Alpha,  RLE, 48 bytes.
static const unsigned char ic_round_24_action_filter_alt_data[] PROGMEM = {
  0x0B, 0xFF, 0x0A, 0x0B, 0xFF, 0x81, 0xB1, 0xEF, 0xD8, 0x2E, 0x10, 0x4F, 0xD0, 0x43, 0x07, 0xFB,
  0x07, 0x50, 0xBF, 0x90, 0xB6, 0x01, 0x0D, 0xE0, 0xD0, 0x17, 0x03, 0xE0, 0x37, 0x20, 0x6C, 0x06,
  0x74, 0xC7, 0x5C, 0x75, 0xC7, 0x5C, 0x75, 0xC7, 0x50, 0xDA, 0x0D, 0x75, 0x82, 0x4D, 0xD4, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_filter_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 4, 19, 19), Box(0, 0, 23, 23),
      ic_round_24_action_filter_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_find_in_page 24x24, 4-bit Alpha,  RLE, 88 bytes.
static const unsigned char ic_round_24_action_find_in_page_data[] PROGMEM = {
  0x04, 0x0D, 0xF0, 0xE0, 0x65, 0x0D, 0xFB, 0x07, 0x4F, 0xD0, 0x73, 0xFE, 0x07, 0x2F, 0xF0, 0x71,
  0xFF, 0x90, 0x6D, 0x0A, 0x03, 0x20, 0x40, 0xBC, 0x0E, 0xC0, 0x76, 0x07, 0xF0, 0xA2, 0x82, 0x8D,
  0xD8, 0x20, 0xAE, 0x81, 0x40, 0x8C, 0x81, 0x80, 0x4E, 0x20, 0xDC, 0x0D, 0x2E, 0x20, 0xDC, 0x0D,
  0x2E, 0x81, 0x40, 0x8C, 0x81, 0x80, 0x4E, 0x0B, 0x28, 0x28, 0xDD, 0x82, 0x0A, 0xF0, 0x87, 0x02,
  0x0E, 0xF8, 0x90, 0xB4, 0x11, 0x4A, 0x20, 0x2E, 0xFD, 0x83, 0xE2, 0x02, 0xEF, 0xD8, 0x3E, 0x20,
  0x2D, 0xFD, 0x83, 0xE2, 0x04, 0xDF, 0xD0, 0xC1,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_find_in_page() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_find_in_page_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_find_replace 24x24, 4-bit Alpha,  RLE, 91 bytes.
static const unsigned char ic_round_24_action_find_replace_data[] PROGMEM = {
  0x48, 0x57, 0xBE, 0xEC, 0x71, 0x20, 0x25, 0x04, 0x0E, 0xE8, 0x1E, 0x47, 0x94, 0x04, 0xA8, 0x4B,
  0x41, 0x03, 0xAC, 0x48, 0x1E, 0xF7, 0x60, 0xBB, 0x38, 0x17, 0xFB, 0x60, 0x7C, 0x38, 0x16, 0xE2,
  0x50, 0x2C, 0x0E, 0x80, 0xC1, 0x00, 0xEC, 0x02, 0x58, 0x12, 0xE6, 0x3C, 0x07, 0x68, 0x1B, 0xF7,
  0x3B, 0x0B, 0x68, 0x27, 0xFE, 0x13, 0xC8, 0x4A, 0x30, 0x14, 0xBA, 0x0D, 0x01, 0x39, 0x81, 0x74,
  0xEE, 0x83, 0xED, 0xFD, 0x12, 0x02, 0x28, 0x93, 0x17, 0xCE, 0xFC, 0x71, 0x1D, 0xFD, 0x17, 0x68,
  0x31, 0xDF, 0xD1, 0x76, 0x82, 0x1D, 0xFD, 0x77, 0x81, 0x1D, 0xC0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_find_replace() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 4, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_find_replace_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_fingerprint 24x24, 4-bit Alpha,  RLE, 176 bytes.
static const unsigned char ic_round_24_action_fingerprint_data[] PROGMEM = {
  0x48, 0x22, 0x7B, 0xDA, 0x82, 0xDB, 0x72, 0x68, 0x41, 0xBD, 0x84, 0x12, 0x84, 0x14, 0x8D, 0xB1,
  0x40, 0x10, 0x52, 0x84, 0x35, 0x77, 0x53, 0x20, 0x50, 0x15, 0x89, 0x22, 0x9E, 0xB9, 0x77, 0x9B,
  0xE9, 0x25, 0x82, 0x7E, 0x71, 0x20, 0x01, 0x28, 0x21, 0x7E, 0x73, 0x8A, 0x6A, 0xB2, 0x05, 0xCF,
  0xDD, 0xFB, 0x60, 0x2B, 0xA0, 0x8B, 0x02, 0xDB, 0x44, 0x8A, 0x74, 0xBC, 0x20, 0xB8, 0x81, 0x3E,
  0x50, 0x27, 0xAA, 0x72, 0x05, 0xE2, 0x18, 0x28, 0x94, 0xD4, 0x08, 0xE8, 0x55, 0x8E, 0x80, 0x5D,
  0x38, 0x96, 0x89, 0x08, 0xB1, 0x02, 0x20, 0x1B, 0x80, 0xA7, 0x28, 0xA7, 0xD2, 0x2E, 0x12, 0xDC,
  0xCC, 0x21, 0xE2, 0x3D, 0x01, 0xD0, 0x79, 0x0C, 0x52, 0x8C, 0x56, 0xB0, 0x97, 0x0E, 0x13, 0xC0,
  0x96, 0x0E, 0x06, 0x40, 0xE0, 0x59, 0x0C, 0x22, 0xC0, 0x86, 0x0F, 0x07, 0x80, 0xB4, 0x20, 0x10,
  0xE2, 0x89, 0x6E, 0x06, 0x80, 0xD2, 0x2D, 0x03, 0xE8, 0x7D, 0x62, 0x89, 0x5C, 0x23, 0xD0, 0x89,
  0x0A, 0x90, 0x17, 0x83, 0x38, 0x94, 0x75, 0x0D, 0x41, 0xE3, 0x0B, 0xB4, 0x11, 0x78, 0x92, 0x4D,
  0x04, 0xE4, 0x05, 0xBD, 0xD5, 0x78, 0x59, 0xB0, 0x3D, 0x93, 0x75, 0x85, 0x91, 0x01, 0x8D, 0x45,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_fingerprint() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_fingerprint_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_fit_screen 24x24, 4-bit Alpha,  RLE, 70 bytes.
static const unsigned char ic_round_24_action_fit_screen_data[] PROGMEM = {
  0x04, 0x0D, 0xA0, 0xB7, 0x30, 0xBA, 0x81, 0xD4, 0xDB, 0x0B, 0x73, 0x0B, 0xB0, 0xDA, 0x77, 0x2C,
  0x77, 0x2A, 0x00, 0xB2, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x20, 0x0B, 0x40, 0xDF, 0xB0, 0xD7, 0x1F,
  0xD7, 0x1F, 0xD7, 0x1F, 0xD7, 0x1F, 0xD7, 0x10, 0xDF, 0xB0, 0xD4, 0x00, 0xB2, 0x04, 0x0D, 0xF9,
  0x0D, 0x04, 0x20, 0x0B, 0xA7, 0x72, 0xC7, 0x72, 0xA0, 0xDB, 0x0B, 0x73, 0x0B, 0xB8, 0x1D, 0x4D,
  0xA0, 0xB7, 0x30, 0xBA, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_fit_screen() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_fit_screen_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_flaky 24x24, 4-bit Alpha,  RLE, 144 bytes.
static const unsigned char ic_round_24_action_flaky_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xA8, 0x3E, 0xAF, 0xDB, 0xE8, 0x29, 0xEF, 0x42, 0x0D, 0xA8, 0x3B, 0x05,
  0x13, 0xD8, 0x57, 0x06, 0xFD, 0x05, 0xC0, 0x52, 0x0D, 0xC0, 0x73, 0x82, 0xCF, 0x59, 0xB0, 0xD0,
  0x12, 0x07, 0xB0, 0x74, 0x82, 0x6F, 0x9D, 0xB8, 0x3B, 0x3D, 0x75, 0xA0, 0x75, 0x82, 0x2F, 0xDE,
  0xFA, 0x07, 0x79, 0x00, 0xEF, 0x90, 0x77, 0x19, 0x0E, 0x0D, 0xF0, 0x74, 0x86, 0x19, 0x10, 0x2F,
  0xD9, 0xE0, 0x72, 0x89, 0x16, 0x21, 0xDE, 0x10, 0x6F, 0x95, 0xD0, 0x73, 0x0F, 0xD0, 0xE0, 0x32,
  0x83, 0xCF, 0x50, 0xDB, 0x07, 0x48, 0x22, 0xDE, 0x32, 0x81, 0x6F, 0xD2, 0x04, 0xA0, 0x96, 0x01,
  0x02, 0x20, 0x4A, 0x04, 0x38, 0x28, 0xFE, 0x67, 0x10, 0x6A, 0x08, 0x50, 0x8A, 0x81, 0xC6, 0x22,
  0x81, 0x26, 0xCA, 0x08, 0x70, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x38, 0x65, 0x9D, 0xEE, 0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_flaky() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_flaky_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_flight_land 24x24, 4-bit Alpha,  RLE, 85 bytes.
static const unsigned char ic_round_24_action_flight_land_data[] PROGMEM = {
  0x71, 0x05, 0x08, 0x77, 0x48, 0x1D, 0xF5, 0x77, 0x38, 0x1D, 0xFA, 0x77, 0x38, 0x1D, 0xFE, 0x72,
  0x81, 0x17, 0x15, 0x0D, 0xA0, 0x47, 0x18, 0x13, 0xF8, 0x50, 0xDA, 0x09, 0x71, 0x81, 0x3F, 0xE5,
  0x0D, 0xA0, 0xD7, 0x10, 0x3A, 0x84, 0xEA, 0x62, 0x0D, 0xB0, 0x27, 0x03, 0xE0, 0xDC, 0x07, 0x71,
  0x08, 0x0D, 0xFA, 0x0D, 0x04, 0x72, 0x82, 0x26, 0xAE, 0xF9, 0x81, 0xB7, 0x37, 0x28, 0x13, 0x7B,
  0xF9, 0x0C, 0x75, 0x81, 0x48, 0xCD, 0x02, 0x77, 0x83, 0x15, 0x9D, 0x98, 0x0F, 0x10, 0x04, 0xFF,
  0xC0, 0x04, 0xFF, 0xC0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_flight_land() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_flight_land_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_flight_takeoff 24x24, 4-bit Alpha,  RLE, 78 bytes.
static const unsigned char ic_round_24_action_flight_takeoff_data[] PROGMEM = {
  0x50, 0x30, 0x17, 0x73, 0x82, 0x3F, 0xD2, 0x77, 0x20, 0x1A, 0x0E, 0x02, 0x77, 0x20, 0x8A, 0x0E,
  0x03, 0x77, 0x20, 0xDA, 0x0E, 0x04, 0x77, 0x10, 0x5C, 0x05, 0x58, 0x13, 0x62, 0x70, 0xCC, 0x83,
  0x62, 0x6A, 0xEA, 0x0E, 0x70, 0x3F, 0xC8, 0x2E, 0x9A, 0x13, 0x81, 0x48, 0xEF, 0x98, 0x7D, 0x93,
  0x8F, 0xD7, 0xBE, 0xF8, 0x2E, 0xA6, 0x24, 0x0D, 0xF9, 0x81, 0xB7, 0x37, 0x10, 0x5C, 0x81, 0xC8,
  0x47, 0x68, 0x28, 0x95, 0x18, 0x09, 0x86, 0x00, 0x4F, 0xFC, 0x00, 0x4F, 0xFC, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_flight_takeoff() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_flight_takeoff_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_flip_to_back 24x24, 4-bit Alpha,  RLE, 62 bytes.
static const unsigned char ic_round_24_action_flip_to_back_data[] PROGMEM = {
  0x40, 0x40, 0xD2, 0xA2, 0xA2, 0x0D, 0x04, 0x40, 0xD9, 0x2A, 0x2A, 0x29, 0x0D, 0x80, 0xC0, 0x00,
  0x0B, 0x2A, 0x73, 0xC2, 0xA7, 0x3C, 0x77, 0x2A, 0x77, 0x2A, 0x2A, 0x73, 0xC2, 0xA7, 0x3C, 0x77,
  0x2A, 0x77, 0x2A, 0x20, 0xD9, 0x2A, 0x2A, 0x29, 0x0D, 0xA2, 0x04, 0x0D, 0x2A, 0x2A, 0x20, 0xD0,
  0x4A, 0x77, 0x2A, 0x03, 0x77, 0x10, 0xDF, 0xD0, 0xB4, 0x04, 0x0D, 0xFC, 0x0B, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_flip_to_back() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_flip_to_back_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_flip_to_front 24x24, 4-bit Alpha,  RLE, 61 bytes.
static const unsigned char ic_round_24_action_flip_to_front_data[] PROGMEM = {
  0x40, 0x40, 0xDF, 0xB0, 0xD0, 0x44, 0x0D, 0xFD, 0x0D, 0x4A, 0x03, 0x71, 0x03, 0xA4, 0xA7, 0x3C,
  0x2A, 0x73, 0xC2, 0xA7, 0x3A, 0x4A, 0x73, 0xA4, 0xA7, 0x3C, 0x2A, 0x73, 0xC2, 0xA7, 0x3A, 0x4A,
  0x73, 0xA4, 0xA0, 0x37, 0x10, 0x3C, 0x20, 0xDF, 0xD0, 0xDA, 0x20, 0x40, 0xDF, 0xB0, 0xD0, 0x48,
  0x0C, 0x00, 0x0D, 0x92, 0xA2, 0xA2, 0xA4, 0x04, 0x0D, 0x2A, 0x2A, 0x2A, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_flip_to_front() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_flip_to_front_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_flutter_dash 24x24, 4-bit Alpha,  RLE, 178 bytes.
static const unsigned char ic_round_24_action_flutter_dash_data[] PROGMEM = {
  0x73, 0x06, 0x77, 0x48, 0x2A, 0xFD, 0x97, 0x68, 0x12, 0x8C, 0xB0, 0x90, 0x27, 0x48, 0x28, 0xE7,
  0x22, 0x82, 0x27, 0xE8, 0x78, 0x24, 0x3B, 0xA7, 0x18, 0x2A, 0xB3, 0x43, 0x8A, 0x29, 0xFE, 0xA5,
  0xCE, 0xC5, 0x5C, 0xEC, 0x5A, 0xEF, 0x90, 0x4A, 0x89, 0x4E, 0x7C, 0x30, 0x3C, 0xC3, 0x03, 0xC7,
  0xEA, 0x04, 0x0B, 0xA8, 0x48, 0xE2, 0x7B, 0x52, 0x84, 0x7B, 0x52, 0xE7, 0xA0, 0xB0, 0xEA, 0x06,
  0x0C, 0x10, 0xFE, 0x20, 0xFE, 0x10, 0xC0, 0x5A, 0x0E, 0xB8, 0x43, 0xD0, 0xCF, 0xC2, 0x84, 0xCF,
  0xC0, 0xD3, 0xA0, 0xE0, 0xCA, 0x89, 0x41, 0xF7, 0x16, 0x28, 0x71, 0x61, 0x7F, 0x1A, 0x8A, 0x3C,
  0x4E, 0xE9, 0xAD, 0x90, 0xAF, 0xE0, 0x8B, 0xDA, 0x9E, 0xE4, 0x28, 0x96, 0xAF, 0x30, 0x19, 0xFD,
  0x31, 0x75, 0x03, 0xFA, 0x48, 0x56, 0xF1, 0x07, 0xE6, 0x68, 0x11, 0xF6, 0x58, 0x3D, 0x34, 0x81,
  0x70, 0x30, 0xD6, 0x81, 0x4D, 0x37, 0x18, 0x13, 0xD4, 0x78, 0x34, 0xDA, 0x51, 0x28, 0x31, 0x5A,
  0xE3, 0x73, 0x81, 0x9D, 0xDA, 0x81, 0xED, 0x57, 0x50, 0x60, 0xA3, 0x82, 0x3E, 0x83, 0x75, 0x81,
  0xAF, 0x92, 0x82, 0x3F, 0xD1, 0x75, 0x81, 0xEF, 0x52, 0x81, 0xEF, 0x97, 0x58, 0x1B, 0xD5, 0x20,
  0x40, 0x55,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_flutter_dash() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 1, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_flutter_dash_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_free_cancellation 24x24, 4-bit Alpha,  RLE, 99 bytes.
static const unsigned char ic_round_24_action_free_cancellation_data[] PROGMEM = {
  0x30, 0x0B, 0x71, 0x00, 0xB7, 0xA7, 0x1A, 0x40, 0x40, 0xDF, 0xF8, 0x2D, 0x40, 0xDF, 0xFA, 0x0D,
  0x1F, 0xFC, 0x1F, 0xFC, 0x1F, 0xFC, 0x1F, 0xFC, 0x1A, 0x77, 0xA1, 0xA1, 0x84, 0x17, 0x11, 0x71,
  0x7A, 0x1A, 0x18, 0x47, 0xFC, 0xCF, 0x77, 0xA1, 0xA1, 0x01, 0x0C, 0xA0, 0xC0, 0x17, 0x0A, 0x0B,
  0x1A, 0x10, 0x10, 0xCA, 0x0C, 0x01, 0x73, 0xA1, 0x84, 0x7F, 0xCC, 0xF7, 0x73, 0xA1, 0x84, 0x17,
  0x11, 0x71, 0x78, 0x14, 0xF9, 0xA7, 0x60, 0x4A, 0x06, 0xA7, 0x18, 0x35, 0xE5, 0x04, 0xA0, 0x81,
  0xA7, 0x10, 0x5A, 0x09, 0xA0, 0x82, 0x0D, 0xF0, 0x82, 0x06, 0xB0, 0x83, 0x04, 0x0D, 0xE0, 0x83,
  0x81, 0x6E, 0x74,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_free_cancellation() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_free_cancellation_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_gavel 24x24, 4-bit Alpha,  RLE, 120 bytes.
static const unsigned char ic_round_24_action_gavel_data[] PROGMEM = {
  0x74, 0x01, 0x77, 0x48, 0x23, 0xEF, 0xB7, 0x72, 0x03, 0x0E, 0xB0, 0xB7, 0x72, 0x0C, 0xC0, 0xB7,
  0x50, 0x30, 0x52, 0x0C, 0xC0, 0xB7, 0x38, 0x23, 0xEF, 0x52, 0x0C, 0xC0, 0x17, 0x10, 0x30, 0xEB,
  0x05, 0x20, 0xCA, 0x0D, 0x72, 0x05, 0xD0, 0x52, 0x81, 0xCE, 0x37, 0x03, 0x20, 0x5D, 0x05, 0x20,
  0x27, 0x81, 0x3E, 0xC2, 0x05, 0xD0, 0x57, 0x20, 0xEA, 0x0C, 0x20, 0x5D, 0x05, 0x70, 0x1C, 0x0C,
  0x20, 0x5D, 0x05, 0x70, 0xBC, 0x0C, 0x20, 0x5D, 0x05, 0x70, 0xBC, 0x0C, 0x20, 0x5D, 0x05, 0x70,
  0xBB, 0x0E, 0x02, 0x20, 0x5D, 0x05, 0x78, 0x2A, 0xFD, 0x34, 0x05, 0xD0, 0x57, 0x01, 0x70, 0x5D,
  0x05, 0x77, 0x10, 0x5D, 0x02, 0x77, 0x10, 0x5C, 0x05, 0x77, 0x20, 0x5A, 0x81, 0xD1, 0xBF, 0xB0,
  0xB5, 0x83, 0x25, 0x10, 0xBF, 0xB0, 0xB7, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_gavel() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_gavel_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_generating_tokens 24x24, 4-bit Alpha,  RLE, 124 bytes.
static const unsigned char ic_round_24_action_generating_tokens_data[] PROGMEM = {
  0x77, 0x30, 0x01, 0x77, 0x60, 0x0A, 0x77, 0x50, 0x3A, 0x03, 0x68, 0x62, 0x8C, 0xEE, 0xC8, 0x22,
  0x01, 0x0A, 0xC0, 0xA0, 0x13, 0x09, 0xF9, 0x82, 0x90, 0x1A, 0xC0, 0xA0, 0x12, 0x0B, 0xFB, 0x0B,
  0x20, 0x3A, 0x03, 0x30, 0x9F, 0xD0, 0x92, 0x00, 0xA3, 0x02, 0xFF, 0x82, 0x20, 0x11, 0x30, 0x8C,
  0x02, 0x40, 0x2C, 0x08, 0x60, 0xCC, 0x0A, 0x07, 0x20, 0x70, 0xAC, 0x0C, 0x60, 0xEE, 0x2E, 0x0E,
  0x60, 0xEE, 0x2E, 0x0E, 0x60, 0xCE, 0x2E, 0x0C, 0x60, 0x8E, 0x2E, 0x08, 0x60, 0x2E, 0x00, 0xAE,
  0x82, 0x20, 0x11, 0x40, 0x9F, 0xD0, 0x92, 0x00, 0xA5, 0x0B, 0xFB, 0x0B, 0x20, 0x3A, 0x03, 0x50,
  0x9F, 0x98, 0x29, 0x01, 0xAC, 0x0A, 0x01, 0x48, 0x62, 0x8C, 0xEE, 0xC8, 0x22, 0x01, 0x0A, 0xC0,
  0xA0, 0x17, 0x72, 0x03, 0xA0, 0x37, 0x75, 0x00, 0xA7, 0x76, 0x00, 0x13,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_generating_tokens() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_generating_tokens_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_get_app 24x24, 4-bit Alpha,  RLE, 41 bytes.
static const unsigned char ic_round_24_action_get_app_data[] PROGMEM = {
  0x40, 0xBC, 0x0B, 0x71, 0xE7, 0x1E, 0x71, 0xE7, 0x1E, 0x71, 0xE5, 0x05, 0xFB, 0x05, 0x20, 0x5F,
  0xB0, 0x53, 0x07, 0xF9, 0x07, 0x50, 0x7E, 0x07, 0x70, 0x7C, 0x07, 0x72, 0x07, 0xA0, 0x77, 0x40,
  0x05, 0x77, 0x77, 0x60, 0xBF, 0xD0, 0x0B, 0xFD, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_get_app() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 18, 19), Box(0, 0, 23, 23),
      ic_round_24_action_get_app_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_gif_box 24x24, 4-bit Alpha,  RLE, 46 bytes.
static const unsigned char ic_round_24_action_gif_box_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0x9B, 0x2F, 0x0A, 0x20, 0x90, 0xF8, 0x20,
  0x9F, 0x90, 0x07, 0xA0, 0xF7, 0x03, 0x08, 0xFA, 0x87, 0x77, 0x88, 0x77, 0x73, 0x8F, 0xA0, 0xA2,
  0x0A, 0x80, 0x08, 0x80, 0x9B, 0x4F, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_gif_box() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_gif_box_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_gif 24x24, 4-bit Alpha,  RLE, 43 bytes.
static const unsigned char ic_round_24_action_gif_data[] PROGMEM = {
  0x0B, 0xB8, 0x4C, 0x05, 0xC0, 0x4B, 0x89, 0x7C, 0xFB, 0x77, 0x50, 0x7F, 0x07, 0xF7, 0x75, 0xF7,
  0x48, 0xA0, 0x7F, 0x07, 0xF7, 0x50, 0xF7, 0x05, 0xC0, 0x7F, 0x07, 0xA8, 0x92, 0xC0, 0xFB, 0x7B,
  0xF0, 0x7F, 0x07, 0x93, 0x0B, 0xB8, 0x5B, 0x05, 0xC0, 0x5C, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_gif() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 9, 18, 14), Box(0, 0, 23, 23),
      ic_round_24_action_gif_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_grade 24x24, 4-bit Alpha,  RLE, 89 bytes.
static const unsigned char ic_round_24_action_grade_data[] PROGMEM = {
  0x72, 0x00, 0x97, 0x73, 0x01, 0xA0, 0x17, 0x72, 0x07, 0xA0, 0x77, 0x72, 0x0D, 0xA0, 0xD7, 0x71,
  0x05, 0xC0, 0x57, 0x48, 0x21, 0x34, 0xCC, 0x82, 0xC4, 0x31, 0x40, 0x20, 0xDF, 0xFA, 0x82, 0xD2,
  0x08, 0xFF, 0xA0, 0x83, 0x06, 0xFF, 0x06, 0x50, 0x40, 0xEF, 0xB0, 0xE0, 0x47, 0x02, 0x0D, 0xF9,
  0x0D, 0x03, 0x72, 0x0A, 0xF9, 0x0A, 0x73, 0x0D, 0xF9, 0x0E, 0x72, 0x02, 0xFB, 0x02, 0x71, 0x05,
  0xC0, 0x08, 0xC0, 0x57, 0x10, 0x9A, 0x0C, 0x02, 0x20, 0x20, 0xBA, 0x09, 0x71, 0x81, 0xCE, 0x56,
  0x81, 0x5E, 0xC7, 0x10, 0x40, 0x17, 0x10, 0x10, 0x44,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_grade() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_grade_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_grading 24x24, 4-bit Alpha,  RLE, 58 bytes.
static const unsigned char ic_round_24_action_grading_data[] PROGMEM = {
  0x0B, 0xFF, 0x00, 0xBF, 0xF0, 0xB7, 0x77, 0x74, 0x0B, 0xFF, 0x00, 0xBF, 0xF0, 0xB7, 0x77, 0x74,
  0x0B, 0xFF, 0x00, 0xBF, 0xF0, 0xB7, 0x77, 0x74, 0x0B, 0xD0, 0xB6, 0x82, 0x17, 0x1B, 0xD0, 0xB5,
  0x82, 0x1C, 0xF7, 0x72, 0x85, 0x89, 0x1C, 0xFC, 0x17, 0x20, 0xDB, 0x82, 0xC1, 0x0B, 0xD0, 0xB2,
  0x83, 0x2E, 0xFC, 0x12, 0x0B, 0xD0, 0xB3, 0x81, 0x27, 0x13,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_grading() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 3, 19, 20), Box(0, 0, 23, 23),
      ic_round_24_action_grading_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_group_work 24x24, 4-bit Alpha,  RLE, 138 bytes.
static const unsigned char ic_round_24_action_group_work_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8D, 0x82, 0xE9, 0x9E, 0xD0, 0x83, 0x04, 0xD0, 0xE0, 0x22, 0x02, 0x0E, 0xD0, 0x42, 0x0D, 0xD0,
  0x94, 0x09, 0xD8, 0x1D, 0x05, 0xE0, 0x94, 0x09, 0xE0, 0x50, 0x9E, 0x0E, 0x02, 0x20, 0x20, 0xEE,
  0x09, 0x0D, 0xF8, 0x2E, 0x99, 0xEF, 0x0D, 0x0E, 0xFF, 0xC0, 0x0E, 0xB8, 0x2E, 0x99, 0xEC, 0x82,
  0xE9, 0x9E, 0xB0, 0xE0, 0xDA, 0x0E, 0x02, 0x20, 0x20, 0xEA, 0x0E, 0x02, 0x20, 0x20, 0xEA, 0x0D,
  0x09, 0xA0, 0x94, 0x09, 0xA0, 0x94, 0x09, 0xA0, 0x90, 0x5A, 0x09, 0x40, 0x9A, 0x09, 0x40, 0x9A,
  0x84, 0x50, 0xDF, 0xE2, 0x20, 0x20, 0xEA, 0x0E, 0x02, 0x28, 0x22, 0xEF, 0xD2, 0x04, 0xA8, 0x2E,
  0x99, 0xEC, 0x82, 0xE9, 0x9E, 0xA0, 0x43, 0x08, 0xFF, 0x08, 0x50, 0x8F, 0xD0, 0x87, 0x04, 0x0D,
  0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_group_work() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_group_work_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_g_translate 24x24, 4-bit Alpha,  RLE, 122 bytes.
static const unsigned char ic_round_24_action_g_translate_data[] PROGMEM = {
  0x04, 0x0D, 0xE0, 0x27, 0x40, 0xDF, 0x06, 0x74, 0xF9, 0x0B, 0x74, 0xFF, 0xC0, 0xD0, 0x4B, 0x82,
  0xC8, 0x7A, 0xA0, 0x57, 0x10, 0x30, 0xDA, 0x07, 0x48, 0x15, 0xF9, 0x72, 0xA8, 0x7A, 0x03, 0xBC,
  0x7D, 0xFE, 0x72, 0xA8, 0x93, 0x40, 0xEF, 0xDD, 0xDD, 0xF3, 0x0A, 0x55, 0xA0, 0x02, 0xA0, 0x13,
  0x0E, 0xF2, 0xA8, 0x96, 0x40, 0xEF, 0x87, 0x11, 0xFC, 0x11, 0x19, 0x91, 0x2A, 0x86, 0xA0, 0x3B,
  0xD7, 0x06, 0xA8, 0x3D, 0x31, 0xE2, 0x3B, 0x07, 0x40, 0x30, 0xEA, 0x82, 0xBC, 0xA8, 0x4C, 0x82,
  0xC8, 0x7A, 0xC8, 0x1A, 0xCE, 0x5F, 0xE8, 0x1C, 0xAA, 0x4F, 0xE8, 0x24, 0x0A, 0xB3, 0x90, 0xDF,
  0xC0, 0x82, 0x0A, 0x03, 0x29, 0x04, 0x0D, 0xFB, 0x0D, 0x69, 0x72, 0x0C, 0xA0, 0x76, 0x97, 0x28,
  0x17, 0xF7, 0x60, 0x30, 0xD7, 0x20, 0x2F, 0x90, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_g_translate() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_g_translate_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_help_center 24x24, 4-bit Alpha,  RLE, 70 bytes.
static const unsigned char ic_round_24_action_help_center_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0xFF, 0xFB, 0x0D, 0x05, 0x20, 0x40, 0xDF, 0xD8,
  0x52, 0x02, 0x30, 0x1E, 0xFC, 0x03, 0x07, 0xA8, 0x16, 0x0A, 0xFF, 0x98, 0x18, 0x09, 0xFF, 0x82,
  0xD1, 0x0E, 0xFE, 0x82, 0xD1, 0x0B, 0xFF, 0x81, 0x50, 0x9F, 0xF9, 0x03, 0x01, 0xFF, 0xA0, 0x0E,
  0xFF, 0xA0, 0xA0, 0x9F, 0xF9, 0x0C, 0x20, 0xCF, 0xF8, 0x2E, 0x22, 0xEF, 0xFF, 0xC0, 0xDF, 0xFA,
  0x81, 0xD4, 0xDF, 0xF0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_help_center() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_help_center_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_help_outline 24x24, 4-bit Alpha,  RLE, 152 bytes.
static const unsigned char ic_round_24_action_help_outline_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x12, 0x6C, 0xA0, 0x85, 0x08, 0xA0, 0x67, 0x10, 0x6A, 0x08, 0x30, 0x4A, 0x04, 0x28, 0x42,
  0xAD, 0xEA, 0x12, 0x04, 0xA0, 0x42, 0x81, 0xDF, 0x62, 0x02, 0x0E, 0xC0, 0xE0, 0x12, 0x85, 0x6F,
  0xD0, 0x5F, 0xC3, 0x86, 0x9F, 0xB1, 0x1A, 0xF9, 0x38, 0x4C, 0xF5, 0x9F, 0x63, 0x81, 0xAD, 0x12,
  0x81, 0x1F, 0xE3, 0x84, 0x6F, 0x9D, 0xF2, 0x71, 0x81, 0x2F, 0xE3, 0x82, 0x2F, 0xDE, 0x97, 0x18,
  0x21, 0xBF, 0x74, 0x90, 0x0E, 0x97, 0x82, 0x1D, 0xF9, 0x59, 0x82, 0xED, 0xF2, 0x68, 0x1A, 0xF9,
  0x58, 0x42, 0xFD, 0x9F, 0x66, 0x81, 0xEF, 0x15, 0x84, 0x6F, 0x95, 0xFC, 0x77, 0x85, 0xCF, 0x50,
  0xDF, 0x65, 0xA5, 0x81, 0x6F, 0xD2, 0x04, 0xA0, 0x44, 0xA4, 0x04, 0xA0, 0x43, 0x08, 0xA0, 0x67,
  0x10, 0x6A, 0x08, 0x50, 0x8A, 0x81, 0xC6, 0x22, 0x81, 0x26, 0xCA, 0x08, 0x70, 0x40, 0xDF, 0x90,
  0xD0, 0x47, 0x38, 0x65, 0x9D, 0xEE, 0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_help_outline() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_help_outline_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_help 24x24, 4-bit Alpha,  RLE, 115 bytes.
static const unsigned char ic_round_24_action_help_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8C, 0x84, 0xD5, 0x01, 0x6E, 0xC0, 0x83, 0x04, 0xC0, 0xD0, 0x14, 0x02, 0x0E, 0xC0, 0x42, 0x0D,
  0xC8, 0x65, 0x04, 0xDD, 0x40, 0x6C, 0x81, 0xD0, 0x5D, 0x81, 0x41, 0xEA, 0x81, 0xD0, 0x1D, 0x05,
  0x09, 0xFB, 0x81, 0xD0, 0x1D, 0x09, 0x0D, 0xFB, 0x81, 0x40, 0x6D, 0x0D, 0x0E, 0xFA, 0x82, 0x50,
  0x3E, 0xD0, 0x0E, 0xF9, 0x82, 0x80, 0x2E, 0xE0, 0xE0, 0xDF, 0x98, 0x12, 0x0B, 0xF0, 0xD0, 0x9F,
  0x92, 0x0E, 0xF0, 0x90, 0x5F, 0xFC, 0x81, 0x50, 0xDF, 0xFA, 0x0D, 0x20, 0x4F, 0x2F, 0x04, 0x30,
  0x8E, 0x2E, 0x08, 0x50, 0x8F, 0xD0, 0x87, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE,
  0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_help() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_help_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_hide_source 24x24, 4-bit Alpha,  RLE, 158 bytes.
static const unsigned char ic_round_24_action_hide_source_data[] PROGMEM = {
  0x78, 0x65, 0xAD, 0xFE, 0xD9, 0x57, 0x09, 0x06, 0x20, 0x30, 0xDF, 0x90, 0xD0, 0x44, 0x01, 0xA0,
  0x72, 0x87, 0xAD, 0x63, 0x10, 0x26, 0xCA, 0x08, 0x40, 0x5A, 0x07, 0x73, 0x06, 0xA0, 0x84, 0x08,
  0xA0, 0x77, 0x30, 0x4A, 0x04, 0x30, 0xDB, 0x07, 0x73, 0x81, 0x6F, 0xD2, 0x82, 0x5F, 0xD5, 0xA0,
  0x77, 0x38, 0x7C, 0xF5, 0x0A, 0xF7, 0x05, 0xA0, 0x77, 0x28, 0x56, 0xF9, 0x0D, 0xF3, 0x20, 0x5A,
  0x07, 0x71, 0x85, 0x2F, 0xD0, 0xEF, 0x13, 0x05, 0xA0, 0x77, 0x19, 0x81, 0xE0, 0xE9, 0x50, 0x5A,
  0x07, 0x68, 0x51, 0xFE, 0x0D, 0xF2, 0x50, 0x5A, 0x07, 0x58, 0x53, 0xFD, 0x0A, 0xF6, 0x60, 0x5A,
  0x07, 0x48, 0x57, 0xFA, 0x05, 0xFC, 0x70, 0x5A, 0x07, 0x38, 0x1D, 0xF5, 0x28, 0x1D, 0xF6, 0x70,
  0x5A, 0x07, 0x20, 0xA0, 0xD3, 0x04, 0xA0, 0x47, 0x05, 0xA0, 0x72, 0x03, 0x40, 0x8A, 0x06, 0x70,
  0x5A, 0x07, 0x70, 0x8A, 0x86, 0xC6, 0x20, 0x13, 0x6D, 0xB0, 0x77, 0x04, 0x0D, 0xF9, 0x0D, 0x08,
  0xA0, 0x67, 0x18, 0x15, 0xAD, 0xA8, 0x1D, 0xA5, 0x28, 0x15, 0xF9, 0x77, 0x50, 0x12,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_hide_source() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_hide_source_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_highlight_alt 24x24, 4-bit Alpha,  RLE, 58 bytes.
static const unsigned char ic_round_24_action_highlight_alt_data[] PROGMEM = {
  0x04, 0x0D, 0x2A, 0x2A, 0x2A, 0x28, 0x1D, 0x4D, 0x92, 0xA2, 0xA2, 0xA2, 0x90, 0xD8, 0x0C, 0x00,
  0xA7, 0x7C, 0x77, 0xA8, 0x0C, 0x00, 0xA7, 0x7C, 0x77, 0xA8, 0x0C, 0x00, 0xA7, 0x30, 0xBC, 0x02,
  0xA7, 0x3C, 0x07, 0x76, 0xB0, 0xE0, 0x17, 0x6A, 0x83, 0xEF, 0xC1, 0xD9, 0x2A, 0x2A, 0x29, 0x85,
  0x71, 0xCF, 0xB4, 0xD2, 0xA2, 0xA2, 0x02, 0x28, 0x11, 0xBA,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_highlight_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_highlight_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_highlight_off 24x24, 4-bit Alpha,  RLE, 158 bytes.
static const unsigned char ic_round_24_action_highlight_off_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x50, 0xDF, 0x90, 0xD0, 0x57, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x12, 0x6C, 0xA0, 0x85, 0x08, 0xA0, 0x67, 0x10, 0x6A, 0x08, 0x30, 0x5A, 0x04, 0x73, 0x04,
  0xA0, 0x52, 0x81, 0xDF, 0x67, 0x58, 0x56, 0xFD, 0x05, 0xFC, 0x38, 0x11, 0x71, 0x28, 0x11, 0x71,
  0x38, 0x4C, 0xF5, 0xAF, 0x63, 0x86, 0x7F, 0xC1, 0x1C, 0xF7, 0x38, 0x46, 0xFA, 0xDF, 0x23, 0x86,
  0x1C, 0xFC, 0xCF, 0xC1, 0x38, 0x22, 0xFD, 0xE9, 0x50, 0x10, 0xCA, 0x0C, 0x01, 0x59, 0x00, 0xE9,
  0x50, 0x10, 0xCA, 0x0C, 0x01, 0x59, 0x82, 0xED, 0xF2, 0x38, 0x61, 0xCF, 0xCC, 0xFC, 0x13, 0x84,
  0x2F, 0xDA, 0xF6, 0x38, 0x67, 0xFC, 0x11, 0xCF, 0x73, 0x84, 0x6F, 0xA5, 0xFC, 0x38, 0x11, 0x71,
  0x28, 0x11, 0x71, 0x38, 0x5C, 0xF5, 0x0D, 0xF6, 0x75, 0x81, 0x6F, 0xD2, 0x05, 0xA0, 0x47, 0x30,
  0x4A, 0x05, 0x30, 0x8A, 0x06, 0x71, 0x06, 0xA0, 0x85, 0x08, 0xA8, 0x1C, 0x62, 0x28, 0x12, 0x6C,
  0xA0, 0x87, 0x05, 0x0D, 0xF9, 0x0D, 0x05, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_highlight_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_highlight_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_history 24x24, 4-bit Alpha,  RLE, 132 bytes.
static const unsigned char ic_round_24_action_history_data[] PROGMEM = {
  0x71, 0x86, 0x49, 0xDE, 0xFD, 0x93, 0x74, 0x02, 0x0B, 0xF9, 0x0B, 0x01, 0x71, 0x84, 0x3E, 0xFE,
  0x72, 0x28, 0x42, 0x7E, 0xFE, 0x36, 0x82, 0x2E, 0xFA, 0x78, 0x31, 0xBF, 0xE1, 0x58, 0x1B, 0xFA,
  0x73, 0x81, 0xBF, 0xB4, 0x81, 0x4F, 0xE5, 0x0C, 0x05, 0x48, 0x21, 0xEF, 0x33, 0x81, 0x9F, 0x75,
  0x90, 0x75, 0x81, 0x7F, 0x93, 0x81, 0xDF, 0x25, 0x90, 0x75, 0x81, 0x3F, 0xD3, 0x0E, 0x96, 0x90,
  0x76, 0x90, 0xE0, 0x2E, 0x02, 0x38, 0x1E, 0xD4, 0x59, 0x81, 0xE0, 0x7C, 0x07, 0x48, 0x34, 0xDF,
  0xA1, 0x28, 0x12, 0xFD, 0x20, 0x7A, 0x07, 0x78, 0x17, 0xE9, 0x28, 0x17, 0xF9, 0x30, 0x07, 0x72,
  0x00, 0x12, 0x81, 0xEF, 0x47, 0x73, 0x81, 0xAF, 0xB7, 0x81, 0x58, 0x17, 0x82, 0xAF, 0xE2, 0x78,
  0x3C, 0xFE, 0x72, 0x28, 0x42, 0x7E, 0xFE, 0x37, 0x10, 0x20, 0xBF, 0x90, 0xB0, 0x27, 0x48, 0x64,
  0x9D, 0xEE, 0xD9, 0x45,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_history() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_history_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_history_toggle_off 24x24, 4-bit Alpha,  RLE, 124 bytes.
static const unsigned char ic_round_24_action_history_toggle_off_data[] PROGMEM = {
  0x68, 0x15, 0xAD, 0x28, 0x1D, 0xA5, 0x75, 0x0B, 0xA2, 0xA0, 0xB7, 0x28, 0x48, 0x80, 0x26, 0x22,
  0x84, 0x26, 0x20, 0x88, 0x58, 0x18, 0xFE, 0x73, 0x81, 0xEF, 0x84, 0x81, 0x7E, 0x47, 0x38, 0x14,
  0xE7, 0x74, 0x00, 0xB7, 0x28, 0x15, 0xB2, 0x6A, 0x68, 0x42, 0xB5, 0xAF, 0x66, 0xA6, 0x84, 0x6F,
  0xAD, 0xF2, 0x6A, 0x68, 0x12, 0xFD, 0x72, 0xA0, 0x17, 0x73, 0x82, 0xBF, 0xC1, 0x78, 0x1D, 0xF2,
  0x68, 0x31, 0xCF, 0xC1, 0x38, 0x42, 0xFD, 0xAF, 0x67, 0x82, 0x1C, 0xFC, 0x38, 0x46, 0xFA, 0x5B,
  0x27, 0x18, 0x21, 0xCF, 0x22, 0x81, 0x2B, 0x57, 0x60, 0x27, 0x18, 0x17, 0xE4, 0x73, 0x81, 0x4E,
  0x84, 0x81, 0x8F, 0xE7, 0x38, 0x1E, 0xF8, 0x58, 0x48, 0x80, 0x26, 0x22, 0x84, 0x26, 0x20, 0x78,
  0x72, 0x0B, 0xA2, 0xA0, 0xB7, 0x58, 0x15, 0xAD, 0x28, 0x1D, 0xA5, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_history_toggle_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_history_toggle_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_hls_off 24x24, 4-bit Alpha,  RLE, 110 bytes.
static const unsigned char ic_round_24_action_hls_off_data[] PROGMEM = {
  0x10, 0x90, 0x67, 0x73, 0x01, 0xA0, 0x77, 0x73, 0x05, 0xA0, 0x77, 0x73, 0x05, 0xA0, 0x77, 0x73,
  0x05, 0xA0, 0x77, 0x73, 0x05, 0xA0, 0x77, 0x78, 0x2C, 0x50, 0x8A, 0x07, 0x50, 0x4C, 0x04, 0x29,
  0x81, 0x70, 0x7B, 0x07, 0x48, 0x47, 0xF7, 0x7D, 0x52, 0xD0, 0x5A, 0x07, 0x38, 0x47, 0xF7, 0x77,
  0x12, 0x98, 0x4B, 0x7B, 0xF0, 0x5A, 0x07, 0x28, 0x41, 0x77, 0x7F, 0x72, 0x98, 0x17, 0x07, 0x92,
  0xB0, 0x72, 0x83, 0x87, 0x7F, 0x72, 0x83, 0xC5, 0x05, 0xC2, 0x0B, 0xB0, 0x72, 0x0A, 0xA0, 0x47,
  0x40, 0x5A, 0x07, 0x77, 0x30, 0x5A, 0x07, 0x77, 0x30, 0x5A, 0x07, 0x77, 0x30, 0x5A, 0x07, 0x77,
  0x30, 0x5A, 0x07, 0x77, 0x30, 0x5A, 0x06, 0x77, 0x38, 0x15, 0xF9, 0x77, 0x40, 0x11,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_hls_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 20, 22), Box(0, 0, 23, 23),
      ic_round_24_action_hls_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_hls 24x24, 4-bit Alpha,  RLE, 54 bytes.
static const unsigned char ic_round_24_action_hls_data[] PROGMEM = {
  0x83, 0xC5, 0x05, 0xC2, 0x0C, 0x05, 0x30, 0x4C, 0x83, 0x4F, 0x70, 0x79, 0x29, 0x07, 0x38, 0x47,
  0xF7, 0x7D, 0x5D, 0x29, 0x07, 0x38, 0x90, 0x7F, 0x77, 0x71, 0xFB, 0x7B, 0x92, 0x90, 0x73, 0x89,
  0x01, 0x77, 0x7F, 0x7F, 0x70, 0x79, 0x29, 0x89, 0x5B, 0x75, 0x05, 0xD7, 0x7F, 0x7C, 0x50, 0x5C,
  0x20, 0xBA, 0x81, 0xC0, 0x4C, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_hls() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 9, 20, 14), Box(0, 0, 23, 23),
      ic_round_24_action_hls_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_home 24x24, 4-bit Alpha,  RLE, 61 bytes.
static const unsigned char ic_round_24_action_home_data[] PROGMEM = {
  0x72, 0x00, 0x67, 0x73, 0x0A, 0xA0, 0xA7, 0x71, 0x0B, 0xC0, 0xB7, 0x50, 0x10, 0xCE, 0x0C, 0x01,
  0x72, 0x02, 0x0D, 0xF9, 0x0D, 0x02, 0x70, 0x30, 0xEF, 0xB0, 0xE0, 0x35, 0x04, 0x0E, 0xFD, 0x0E,
  0x04, 0x30, 0x5F, 0xFA, 0x81, 0x50, 0x1F, 0xFC, 0x01, 0x3F, 0xF6, 0xFF, 0x6D, 0x4D, 0x6D, 0x4D,
  0x6D, 0x4D, 0x6D, 0x4D, 0x6D, 0x4D, 0x60, 0xBB, 0x0B, 0x40, 0xBB, 0x0B, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_home() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_home_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_horizontal_split 24x24, 4-bit Alpha,  RLE, 28 bytes.
static const unsigned char ic_round_24_action_horizontal_split_data[] PROGMEM = {
  0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB8, 0x0C, 0x00, 0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB8,
  0x0C, 0x00, 0x0B, 0xFF, 0xA0, 0xB8, 0x09, 0x84, 0xF0, 0xBF, 0xFA, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_horizontal_split() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 5, 20, 18), Box(0, 0, 23, 23),
      ic_round_24_action_horizontal_split_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_hotel_class 24x24, 4-bit Alpha,  RLE, 117 bytes.
static const unsigned char ic_round_24_action_hotel_class_data[] PROGMEM = {
  0x71, 0x00, 0x52, 0x03, 0x07, 0x77, 0x10, 0x0B, 0x20, 0x90, 0xE7, 0x70, 0x1A, 0x83, 0x10, 0xCF,
  0x37, 0x60, 0x5A, 0x83, 0x50, 0x8F, 0x87, 0x60, 0xAA, 0x83, 0xA0, 0x3F, 0xD7, 0x60, 0xEA, 0x0E,
  0x77, 0x20, 0x4C, 0x04, 0x72, 0x0C, 0xFF, 0xA0, 0xC3, 0x01, 0x0C, 0xFF, 0x0B, 0x01, 0x50, 0x7F,
  0xD0, 0x77, 0x10, 0x30, 0xDF, 0x90, 0xD0, 0x32, 0x07, 0xA0, 0x75, 0x0E, 0xE0, 0xE2, 0x01, 0x0B,
  0xA0, 0x85, 0x02, 0xF9, 0x84, 0x20, 0xBF, 0xE4, 0x60, 0x7F, 0x98, 0x37, 0x06, 0xFA, 0x70, 0xBB,
  0x00, 0xAB, 0x83, 0xC0, 0x2F, 0xE6, 0x01, 0xB0, 0x72, 0x07, 0xB8, 0x31, 0x0C, 0xF4, 0x58, 0x26,
  0xFD, 0x34, 0x86, 0x3D, 0xF6, 0x07, 0xF9, 0x58, 0x1A, 0xB1, 0x68, 0x11, 0xBA, 0x20, 0x90, 0xD5,
  0x01, 0x73, 0x01, 0x30, 0x12,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_hotel_class() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 22, 21), Box(0, 0, 23, 23),
      ic_round_24_action_hotel_class_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_hourglass_disabled 24x24, 4-bit Alpha,  RLE, 122 bytes.
static const unsigned char ic_round_24_action_hourglass_disabled_data[] PROGMEM = {
  0x03, 0x04, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x44, 0x81, 0xCF, 0x72, 0x09, 0xFB, 0x0D, 0x40, 0x5A,
  0x07, 0x20, 0xA0, 0x36, 0x03, 0xA5, 0x05, 0xA0, 0x77, 0x3A, 0x60, 0x5A, 0x07, 0x72, 0xA7, 0x05,
  0xA0, 0x77, 0x81, 0x1F, 0xE7, 0x10, 0x5A, 0x07, 0x58, 0x21, 0xDF, 0x67, 0x20, 0x5A, 0x07, 0x38,
  0x21, 0xDF, 0x77, 0x40, 0x5A, 0x07, 0x28, 0x18, 0xF7, 0x76, 0x05, 0xA0, 0x72, 0x05, 0x77, 0x10,
  0xAA, 0x07, 0x77, 0x28, 0x17, 0xFD, 0xA0, 0x77, 0x78, 0x37, 0xFD, 0x15, 0xA0, 0x77, 0x58, 0x26,
  0xFD, 0x12, 0x05, 0xA0, 0x77, 0x48, 0x1E, 0xF1, 0x40, 0x5A, 0x07, 0x73, 0xA6, 0x05, 0xA0, 0x77,
  0x2A, 0x70, 0x5A, 0x07, 0x71, 0xA0, 0x36, 0x03, 0xB0, 0x77, 0x0D, 0xFB, 0x0E, 0xA0, 0x76, 0x04,
  0x0D, 0xF9, 0x81, 0xD4, 0x5A, 0x04, 0x77, 0x48, 0x15, 0xC3,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_hourglass_disabled() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_hourglass_disabled_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_hourglass_empty 24x24, 4-bit Alpha,  RLE, 83 bytes.
static const unsigned char ic_round_24_action_hourglass_empty_data[] PROGMEM = {
  0x04, 0x0D, 0xF9, 0x81, 0xD4, 0xDF, 0xB0, 0xDA, 0x03, 0x60, 0x3C, 0x71, 0xC7, 0x1A, 0x81, 0xEF,
  0x16, 0x85, 0x1F, 0xE6, 0xFD, 0x14, 0x87, 0x1D, 0xF6, 0x07, 0xFD, 0x12, 0x82, 0x1D, 0xF7, 0x38,
  0x67, 0xFD, 0x11, 0xDF, 0x75, 0x84, 0x7F, 0xDD, 0xF7, 0x68, 0x47, 0xFD, 0xDF, 0x75, 0x86, 0x7F,
  0xD1, 0x1D, 0xF7, 0x38, 0x27, 0xFD, 0x12, 0x87, 0x1D, 0xF7, 0x06, 0xFD, 0x14, 0x85, 0x1D, 0xF6,
  0xEF, 0x16, 0x81, 0x1F, 0xEA, 0x71, 0xC7, 0x1C, 0x03, 0x60, 0x3A, 0x0D, 0xFB, 0x81, 0xD4, 0xDF,
  0x90, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_hourglass_empty() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(6, 2, 17, 21), Box(0, 0, 23, 23),
      ic_round_24_action_hourglass_empty_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_hourglass_full 24x24, 4-bit Alpha,  RLE, 52 bytes.
static const unsigned char ic_round_24_action_hourglass_full_data[] PROGMEM = {
  0x04, 0x0D, 0xF9, 0x81, 0xD4, 0xDF, 0xB0, 0xD8, 0x0C, 0x0F, 0x0E, 0xFB, 0x0E, 0x06, 0xFB, 0x81,
  0x60, 0x7F, 0x90, 0x73, 0x07, 0xE0, 0x75, 0x07, 0xC0, 0x76, 0x07, 0xC0, 0x75, 0x07, 0xE0, 0x73,
  0x07, 0xF9, 0x81, 0x70, 0x6F, 0xB0, 0x60, 0xEF, 0xB0, 0xE8, 0x0C, 0x0F, 0x0D, 0xFB, 0x81, 0xD4,
  0xDF, 0x90, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_hourglass_full() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(6, 2, 17, 21), Box(0, 0, 23, 23),
      ic_round_24_action_hourglass_full_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_html 24x24, 4-bit Alpha,  RLE, 76 bytes.
static const unsigned char ic_round_24_action_html_data[] PROGMEM = {
  0x85, 0xC5, 0x05, 0xC0, 0xCB, 0x81, 0xC0, 0xBD, 0x82, 0x40, 0xC5, 0x29, 0x8A, 0x37, 0x07, 0xF0,
  0x59, 0xF9, 0x50, 0xFB, 0xBF, 0x7F, 0x70, 0xF7, 0x2D, 0x28, 0x13, 0xF3, 0x29, 0x87, 0x77, 0xF0,
  0xF7, 0x0F, 0x72, 0x98, 0x1B, 0x7B, 0x92, 0x81, 0x3F, 0x32, 0x98, 0x77, 0x7F, 0x0F, 0x70, 0xF7,
  0x29, 0x81, 0x70, 0x79, 0x28, 0x13, 0xF3, 0x29, 0x89, 0x67, 0x5C, 0x0F, 0x70, 0xFB, 0x75, 0xC5,
  0x05, 0xC2, 0x81, 0x2D, 0x22, 0x0C, 0x05, 0x38, 0x2C, 0x50, 0xBA, 0x0C,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_html() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 9, 23, 14), Box(0, 0, 23, 23),
      ic_round_24_action_html_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_http 24x24, 4-bit Alpha,  RLE, 61 bytes.
static const unsigned char ic_round_24_action_http_data[] PROGMEM = {
  0x85, 0xC5, 0x05, 0xC0, 0xCB, 0x00, 0x5B, 0x81, 0xC0, 0xBB, 0x8A, 0x48, 0xF7, 0x07, 0xF0, 0x5B,
  0xF7, 0x11, 0x7F, 0xB5, 0x0F, 0xB7, 0xBE, 0x20, 0x79, 0x49, 0x07, 0x29, 0x81, 0xB7, 0xBA, 0x81,
  0xB7, 0xB9, 0x20, 0x79, 0x49, 0x07, 0x2C, 0x83, 0x8F, 0x70, 0x79, 0x20, 0x79, 0x49, 0x07, 0x29,
  0x07, 0x38, 0x3C, 0x50, 0x5C, 0x20, 0x50, 0xC4, 0x0C, 0x05, 0x20, 0xC0, 0x53,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_http() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 9, 22, 14), Box(0, 0, 23, 23),
      ic_round_24_action_http_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_https 24x24, 4-bit Alpha,  RLE, 65 bytes.
static const unsigned char ic_round_24_action_https_data[] PROGMEM = {
  0x58, 0x44, 0xBE, 0xEB, 0x47, 0x20, 0x8E, 0x08, 0x70, 0x4A, 0x82, 0x71, 0x17, 0xA0, 0x46, 0x81,
  0xBF, 0x74, 0x81, 0x7F, 0xB6, 0x81, 0xEF, 0x14, 0x81, 0x1F, 0xE6, 0xA6, 0xA6, 0xA6, 0xA3, 0x04,
  0x0D, 0xFD, 0x81, 0xD4, 0xDF, 0xF0, 0xD8, 0x0E, 0x2F, 0x82, 0xB1, 0x1B, 0xFD, 0x01, 0x20, 0x1F,
  0xD0, 0x12, 0x01, 0xFD, 0x82, 0xB1, 0x1B, 0x80, 0xE2, 0xF0, 0xDF, 0xF8, 0x1D, 0x4D, 0xFD, 0x0D,
  0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_https() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 1, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_https_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_important_devices 24x24, 4-bit Alpha,  RLE, 102 bytes.
static const unsigned char ic_round_24_action_important_devices_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xC0, 0xD0, 0x42, 0x0D, 0xFF, 0xE0, 0xD2, 0xA0, 0x37, 0x72, 0x03, 0xA2, 0xA7,
  0x74, 0xA2, 0xA7, 0x10, 0x02, 0x71, 0xA2, 0xA7, 0x10, 0x07, 0x71, 0xA2, 0xA7, 0x10, 0x0C, 0x71,
  0x00, 0xB2, 0xA5, 0x05, 0x0E, 0xC0, 0xE0, 0x57, 0x2A, 0x60, 0x10, 0xCA, 0x0C, 0x01, 0x73, 0xA7,
  0x0B, 0xA0, 0xB4, 0x0B, 0xD0, 0xBA, 0x68, 0x41, 0xD3, 0x3D, 0x13, 0xFA, 0x60, 0x20, 0x12, 0x01,
  0x02, 0x39, 0x5B, 0x77, 0x19, 0x5B, 0x03, 0x77, 0x95, 0x90, 0xDF, 0xE0, 0xB2, 0x95, 0x90, 0x40,
  0xDF, 0xD0, 0xB2, 0x95, 0x97, 0x2C, 0x49, 0x59, 0x72, 0xC4, 0x95, 0x97, 0x0B, 0xE0, 0xB2, 0xF7,
  0x0B, 0xE0, 0xB2, 0x0B, 0xD0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_important_devices() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 2, 23, 21), Box(0, 0, 23, 23),
      ic_round_24_action_important_devices_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_info_outline 24x24, 4-bit Alpha,  RLE, 124 bytes.
static const unsigned char ic_round_24_action_info_outline_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x12, 0x6C, 0xA0, 0x85, 0x08, 0xA0, 0x67, 0x10, 0x6A, 0x08, 0x30, 0x4A, 0x04, 0x73, 0x04,
  0xA0, 0x42, 0x81, 0xDF, 0x65, 0xA5, 0x85, 0x6F, 0xD0, 0x5F, 0xC6, 0xA6, 0x84, 0xCF, 0x59, 0xF6,
  0x77, 0x84, 0x6F, 0x9D, 0xF2, 0x77, 0x82, 0x2F, 0xDE, 0x97, 0x00, 0xB7, 0x90, 0x0E, 0x97, 0xA7,
  0x98, 0x2E, 0xDF, 0x26, 0xA6, 0x84, 0x2F, 0xD9, 0xF6, 0x6A, 0x68, 0x46, 0xF9, 0x5F, 0xC6, 0xA6,
  0x85, 0xCF, 0x50, 0xDF, 0x65, 0x00, 0xB5, 0x81, 0x6F, 0xD2, 0x04, 0xA0, 0x47, 0x30, 0x4A, 0x04,
  0x30, 0x8A, 0x06, 0x71, 0x06, 0xA0, 0x85, 0x08, 0xA8, 0x1C, 0x62, 0x28, 0x12, 0x6C, 0xA0, 0x87,
  0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_info_outline() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_info_outline_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_info 24x24, 4-bit Alpha,  RLE, 90 bytes.
static const unsigned char ic_round_24_action_info_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFF, 0xA0, 0x42, 0x0D, 0xF2, 0xF8, 0x1D, 0x05, 0xF9, 0x2F, 0x90, 0x50,
  0x9F, 0xFC, 0x09, 0x0D, 0xFF, 0xC0, 0xD0, 0xEF, 0x90, 0x03, 0xF9, 0x00, 0xEF, 0x92, 0xF9, 0x0E,
  0x0D, 0xF9, 0x2F, 0x90, 0xD0, 0x9F, 0x92, 0xF9, 0x09, 0x05, 0xF9, 0x2F, 0x98, 0x15, 0x0D, 0xF0,
  0x03, 0xF0, 0xD2, 0x04, 0xFF, 0xA0, 0x43, 0x08, 0xFF, 0x08, 0x50, 0x8F, 0xD0, 0x87, 0x04, 0x0D,
  0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_info() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_info_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_input 24x24, 4-bit Alpha,  RLE, 67 bytes.
static const unsigned char ic_round_24_action_input_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xE0, 0xDA, 0x03, 0x77, 0x20, 0x3C, 0x77, 0x4C, 0x77,
  0x4A, 0x00, 0xB7, 0x10, 0x27, 0x2A, 0x73, 0x90, 0x77, 0x1A, 0x73, 0xA0, 0x77, 0xA0, 0xBF, 0xD0,
  0x76, 0xA0, 0xBF, 0xD0, 0x76, 0xA7, 0x3A, 0x07, 0x7A, 0x73, 0x90, 0x77, 0x1A, 0x00, 0xB7, 0x10,
  0x27, 0x2C, 0x77, 0x4C, 0x77, 0x4C, 0x03, 0x77, 0x20, 0x3A, 0x0D, 0xFF, 0xE8, 0x1D, 0x4D, 0xFF,
  0xC0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_input() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_input_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_install_desktop 24x24, 4-bit Alpha,  RLE, 69 bytes.
static const unsigned char ic_round_24_action_install_desktop_data[] PROGMEM = {
  0x04, 0x0D, 0xF9, 0x40, 0x0B, 0x40, 0xDF, 0xA4, 0xA4, 0xA7, 0x5A, 0x4A, 0x75, 0xA4, 0xA7, 0x5A,
  0x4A, 0x71, 0x81, 0x5D, 0x51, 0xA1, 0x81, 0x5D, 0x5A, 0x71, 0x05, 0xA0, 0x5A, 0x05, 0xA0, 0x5A,
  0x72, 0x07, 0xE0, 0x71, 0xA7, 0x30, 0x7C, 0x07, 0x2A, 0x74, 0x07, 0xA0, 0x73, 0xA7, 0x50, 0x05,
  0x4A, 0x77, 0x2C, 0x77, 0x2C, 0x77, 0x2A, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD0, 0x46,
  0xF9, 0x75, 0x0B, 0xE0, 0xB6,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_install_desktop() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_install_desktop_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_install_mobile 24x24, 4-bit Alpha,  RLE, 73 bytes.
static const unsigned char ic_round_24_action_install_mobile_data[] PROGMEM = {
  0x04, 0x0D, 0xF7, 0x20, 0xDF, 0x97, 0x2F, 0xA3, 0x00, 0xB4, 0xFA, 0x3A, 0x4F, 0xA3, 0xA4, 0xA7,
  0x3A, 0x4A, 0x73, 0xA4, 0xA6, 0x81, 0x5D, 0x51, 0xA1, 0x81, 0x5D, 0x5A, 0x60, 0x5A, 0x05, 0xA0,
  0x5A, 0x05, 0xA7, 0x07, 0xE0, 0x71, 0xA7, 0x10, 0x7C, 0x07, 0x2A, 0x72, 0x07, 0xA0, 0x73, 0xA7,
  0x30, 0x05, 0x4A, 0x77, 0x2A, 0x77, 0x2A, 0x73, 0xA4, 0xA7, 0x3A, 0x4F, 0xF4, 0xFF, 0x4F, 0xF4,
  0x0D, 0xFD, 0x0D, 0x40, 0x40, 0xDF, 0xB0, 0xD0, 0x44,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_install_mobile() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_install_mobile_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_integration_instructions 24x24, 4-bit Alpha,  RLE, 76 bytes.
static const unsigned char ic_round_24_action_integration_instructions_data[] PROGMEM = {
  0x78, 0x28, 0xEE, 0x87, 0x68, 0x48, 0xFE, 0xEF, 0x86, 0x04, 0x0E, 0xE0, 0x05, 0xE8, 0x1D, 0x4D,
  0xF0, 0x0E, 0xF0, 0xD8, 0x0F, 0x0F, 0x0E, 0xC0, 0xEF, 0xC8, 0x18, 0x08, 0xA8, 0x18, 0x07, 0xFA,
  0x07, 0x20, 0xBA, 0x0B, 0x20, 0x7F, 0x0A, 0x20, 0xAC, 0x0A, 0x20, 0xAE, 0x0A, 0x20, 0xAC, 0x0A,
  0x20, 0xAF, 0x07, 0x20, 0xBA, 0x0B, 0x20, 0x7F, 0xA8, 0x17, 0x08, 0xA8, 0x18, 0x08, 0xFC, 0x0E,
  0xC0, 0xE8, 0x0F, 0x0F, 0x0D, 0xFF, 0xA8, 0x1D, 0x4E, 0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_integration_instructions() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 1, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_integration_instructions_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_invert_colors 24x24, 4-bit Alpha,  RLE, 83 bytes.
static const unsigned char ic_round_24_action_invert_colors_data[] PROGMEM = {
  0x70, 0x05, 0x76, 0x08, 0xA0, 0x87, 0x40, 0x8C, 0x08, 0x72, 0x08, 0xA0, 0x4B, 0x08, 0x70, 0x8A,
  0x04, 0x1C, 0x08, 0x50, 0x8A, 0x04, 0x2D, 0x08, 0x38, 0x26, 0xFE, 0x43, 0xE8, 0x46, 0x01, 0xEF,
  0x54, 0xE8, 0x3E, 0x17, 0xFA, 0x5F, 0x82, 0x7C, 0xF4, 0x5F, 0x82, 0xCE, 0xF1, 0x5F, 0x00, 0xE9,
  0x6F, 0x82, 0xED, 0xF3, 0x5F, 0x82, 0xD9, 0xF8, 0x5F, 0x83, 0x93, 0xFE, 0x24, 0xF8, 0x43, 0x09,
  0xFD, 0x23, 0xE0, 0x93, 0x0B, 0xA0, 0x80, 0x31, 0xD0, 0xB5, 0x09, 0xF9, 0x09, 0x78, 0x62, 0x8C,
  0xEE, 0xC8, 0x24,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_invert_colors() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 20), Box(0, 0, 23, 23),
      ic_round_24_action_invert_colors_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_javascript 24x24, 4-bit Alpha,  RLE, 33 bytes.
static const unsigned char ic_round_24_action_javascript_data[] PROGMEM = {
  0x38, 0x2C, 0x50, 0xBB, 0x0B, 0x39, 0x85, 0x70, 0xFB, 0x79, 0xC3, 0x98, 0xB4, 0x70, 0xFB, 0x77,
  0x45, 0x10, 0xF7, 0x04, 0x77, 0xBF, 0xEB, 0x7F, 0x70, 0xC9, 0x7B, 0xF8, 0xA8, 0x2D, 0x20, 0xBB,
  0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_javascript() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(6, 9, 16, 14), Box(0, 0, 23, 23),
      ic_round_24_action_javascript_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_join_full 24x24, 4-bit Alpha,  RLE, 128 bytes.
static const unsigned char ic_round_24_action_join_full_data[] PROGMEM = {
  0x38, 0x51, 0x7C, 0xEE, 0xC2, 0x28, 0x53, 0xCE, 0xEC, 0x71, 0x50, 0x50, 0xEC, 0x84, 0x80, 0x33,
  0x09, 0xC0, 0xE0, 0x53, 0x05, 0xD8, 0x1C, 0x04, 0xA8, 0x14, 0x0C, 0xD8, 0x25, 0x01, 0xED, 0x81,
  0x51, 0xEA, 0x81, 0xE1, 0x5D, 0x81, 0xE1, 0x7D, 0x81, 0xE0, 0x7C, 0x81, 0x70, 0xED, 0x07, 0x0C,
  0xD8, 0x1A, 0x0C, 0xC8, 0x1C, 0x0A, 0xD0, 0xC0, 0xED, 0x81, 0x80, 0xEC, 0x81, 0xE0, 0x8D, 0x00,
  0xED, 0x81, 0x80, 0xEC, 0x81, 0xE0, 0x8D, 0x0E, 0x0C, 0xD8, 0x1A, 0x0C, 0xC8, 0x1C, 0x0A, 0xD0,
  0xC0, 0x7D, 0x81, 0xE0, 0x7C, 0x81, 0x70, 0xED, 0x81, 0x71, 0xED, 0x81, 0x51, 0xEA, 0x81, 0xE1,
  0x5D, 0x82, 0xE1, 0x05, 0xD8, 0x1C, 0x04, 0xA8, 0x14, 0x0C, 0xD0, 0x53, 0x05, 0x0E, 0xC8, 0x49,
  0x03, 0x30, 0x8C, 0x0E, 0x05, 0x58, 0x51, 0x7C, 0xEE, 0xC3, 0x28, 0x52, 0xCE, 0xEC, 0x71, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_join_full() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 5, 22, 18), Box(0, 0, 23, 23),
      ic_round_24_action_join_full_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_join_inner 24x24, 4-bit Alpha,  RLE, 128 bytes.
static const unsigned char ic_round_24_action_join_inner_data[] PROGMEM = {
  0x38, 0x51, 0x7C, 0xEE, 0xC2, 0x28, 0x52, 0xCE, 0xEC, 0x71, 0x50, 0x50, 0xEC, 0x84, 0x80, 0x33,
  0x08, 0xC0, 0xE0, 0x53, 0x05, 0xA8, 0x4A, 0x30, 0x10, 0x4A, 0x84, 0x40, 0x10, 0x3A, 0xA8, 0x45,
  0x01, 0xEF, 0x74, 0x01, 0x0E, 0xA0, 0xE0, 0x14, 0x85, 0x7F, 0xE1, 0x7F, 0xA5, 0x07, 0xC0, 0x75,
  0x84, 0xAF, 0x7C, 0xF3, 0x50, 0xCC, 0x0C, 0x58, 0x23, 0xFC, 0xE9, 0x60, 0xEC, 0x0E, 0x69, 0x00,
  0xE9, 0x60, 0xEC, 0x0E, 0x69, 0x82, 0xEC, 0xF3, 0x50, 0xCC, 0x0C, 0x58, 0x43, 0xFC, 0x7F, 0xA5,
  0x07, 0xC0, 0x75, 0x85, 0xAF, 0x71, 0xEF, 0x74, 0x01, 0x0E, 0xA0, 0xE0, 0x14, 0x84, 0x7F, 0xE1,
  0x05, 0xA8, 0x4A, 0x30, 0x10, 0x4A, 0x84, 0x40, 0x10, 0x3A, 0xA0, 0x53, 0x05, 0x0E, 0xC8, 0x48,
  0x03, 0x30, 0x8C, 0x0E, 0x05, 0x58, 0x51, 0x7C, 0xEE, 0xC2, 0x28, 0x52, 0xCE, 0xEC, 0x71, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_join_inner() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 5, 22, 18), Box(0, 0, 23, 23),
      ic_round_24_action_join_inner_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_join_left 24x24, 4-bit Alpha,  RLE, 128 bytes.
static const unsigned char ic_round_24_action_join_left_data[] PROGMEM = {
  0x38, 0x51, 0x7C, 0xEE, 0xC2, 0x28, 0x52, 0xCE, 0xEC, 0x71, 0x50, 0x50, 0xEC, 0x84, 0x80, 0x33,
  0x08, 0xC0, 0xE0, 0x53, 0x05, 0xD8, 0x1C, 0x04, 0xA8, 0x44, 0x01, 0x03, 0xAA, 0x82, 0x50, 0x1E,
  0xD8, 0x15, 0x1E, 0xA0, 0xE0, 0x14, 0x83, 0x7F, 0xE1, 0x7D, 0x81, 0xE0, 0x7C, 0x07, 0x58, 0x2A,
  0xF7, 0xCD, 0x81, 0xA0, 0xCC, 0x0C, 0x58, 0x23, 0xFC, 0xED, 0x81, 0x80, 0xEC, 0x0E, 0x69, 0x00,
  0xED, 0x81, 0x80, 0xEC, 0x0E, 0x69, 0x0E, 0x0C, 0xD8, 0x1A, 0x0C, 0xC0, 0xC5, 0x82, 0x3F, 0xC7,
  0xD8, 0x1E, 0x07, 0xC0, 0x75, 0x83, 0xAF, 0x71, 0xED, 0x81, 0x51, 0xEA, 0x0E, 0x01, 0x48, 0x47,
  0xFE, 0x10, 0x5D, 0x81, 0xC0, 0x4A, 0x84, 0x40, 0x10, 0x3A, 0xA0, 0x53, 0x05, 0x0E, 0xC8, 0x49,
  0x03, 0x30, 0x8C, 0x0E, 0x05, 0x58, 0x51, 0x7C, 0xEE, 0xC3, 0x28, 0x52, 0xCE, 0xEC, 0x71, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_join_left() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 5, 22, 18), Box(0, 0, 23, 23),
      ic_round_24_action_join_left_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_join_right 24x24, 4-bit Alpha,  RLE, 128 bytes.
static const unsigned char ic_round_24_action_join_right_data[] PROGMEM = {
  0x38, 0x51, 0x7C, 0xEE, 0xC2, 0x28, 0x53, 0xCE, 0xEC, 0x71, 0x50, 0x50, 0xEC, 0x84, 0x80, 0x33,
  0x09, 0xC0, 0xE0, 0x53, 0x05, 0xA8, 0x4A, 0x30, 0x10, 0x4A, 0x81, 0x40, 0xCD, 0x84, 0x50, 0x1E,
  0xF7, 0x40, 0x10, 0xEA, 0x81, 0xE1, 0x5D, 0x83, 0xE1, 0x7F, 0xA5, 0x07, 0xC8, 0x17, 0x0E, 0xD8,
  0x27, 0xCF, 0x35, 0x0C, 0xC8, 0x1C, 0x0A, 0xD0, 0xC0, 0xE9, 0x60, 0xEC, 0x81, 0xE0, 0x8D, 0x00,
  0xE9, 0x60, 0xEC, 0x81, 0xE0, 0x8D, 0x82, 0xEC, 0xF3, 0x50, 0xCC, 0x81, 0xC0, 0xAD, 0x82, 0xC7,
  0xFA, 0x50, 0x7C, 0x81, 0x70, 0xED, 0x83, 0x71, 0xEF, 0x74, 0x01, 0x0E, 0xA8, 0x1E, 0x15, 0xD8,
  0x2E, 0x10, 0x5A, 0x84, 0xA3, 0x01, 0x04, 0xA8, 0x14, 0x0C, 0xD0, 0x53, 0x05, 0x0E, 0xC8, 0x48,
  0x03, 0x30, 0x8C, 0x0E, 0x05, 0x58, 0x51, 0x7C, 0xEE, 0xC2, 0x28, 0x52, 0xCE, 0xEC, 0x71, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_join_right() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 5, 22, 18), Box(0, 0, 23, 23),
      ic_round_24_action_join_right_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_label_important_outline 24x24, 4-bit Alpha,  RLE, 83 bytes.
static const unsigned char ic_round_24_action_label_important_outline_data[] PROGMEM = {
  0x0D, 0xFB, 0x0D, 0x04, 0x40, 0xEF, 0xC0, 0xE0, 0x23, 0x81, 0x6F, 0xC7, 0x18, 0x1A, 0xFC, 0x48,
  0x1B, 0xF8, 0x78, 0x21, 0xDF, 0x83, 0x82, 0x2E, 0xF3, 0x70, 0x3A, 0x03, 0x38, 0x27, 0xFD, 0x17,
  0x81, 0x8F, 0xD4, 0x81, 0xCF, 0xA7, 0x18, 0x1C, 0xF9, 0x38, 0x1C, 0xFA, 0x71, 0x81, 0xCF, 0x92,
  0x82, 0x7F, 0xD1, 0x78, 0x18, 0xFD, 0x28, 0x22, 0xEF, 0x37, 0x03, 0xA0, 0x32, 0x81, 0xBF, 0x87,
  0x82, 0x1D, 0xF8, 0x28, 0x16, 0xFC, 0x71, 0x81, 0xAF, 0xC3, 0x0E, 0xFC, 0x0E, 0x02, 0x30, 0xDF,
  0xB0, 0xD0, 0x44,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_label_important_outline() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 5, 20, 18), Box(0, 0, 23, 23),
      ic_round_24_action_label_important_outline_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_label_important 24x24, 4-bit Alpha,  RLE, 55 bytes.
static const unsigned char ic_round_24_action_label_important_data[] PROGMEM = {
  0x0C, 0xFA, 0x0D, 0x04, 0x40, 0xDF, 0xB0, 0xE0, 0x23, 0x03, 0xFC, 0x0C, 0x40, 0x7F, 0xC0, 0x74,
  0x0B, 0xFC, 0x03, 0x30, 0x20, 0xEF, 0xB0, 0xD4, 0x05, 0xFC, 0x08, 0x30, 0x5F, 0xC0, 0x82, 0x02,
  0x0E, 0xFB, 0x0D, 0x30, 0xBF, 0xC0, 0x32, 0x07, 0xFC, 0x07, 0x20, 0x3F, 0xC0, 0xC3, 0x0D, 0xFB,
  0x0E, 0x02, 0x30, 0xCF, 0xA0, 0xD0, 0x44,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_label_important() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 5, 20, 18), Box(0, 0, 23, 23),
      ic_round_24_action_label_important_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_label_off 24x24, 4-bit Alpha,  RLE, 89 bytes.
static const unsigned char ic_round_24_action_label_off_data[] PROGMEM = {
  0x81, 0x5D, 0x57, 0x73, 0x05, 0xA0, 0x57, 0x73, 0x09, 0xA0, 0x52, 0x0C, 0xE0, 0xD0, 0x45, 0x0D,
  0xB0, 0x52, 0x0C, 0xE0, 0xE0, 0x24, 0xD0, 0x52, 0x0C, 0xE0, 0xC4, 0xE0, 0x52, 0x0C, 0xE0, 0x83,
  0xF0, 0x52, 0x0C, 0xE0, 0x32, 0xF9, 0x82, 0x50, 0x1C, 0xD0, 0xD2, 0xFA, 0x82, 0x50, 0x1C, 0xD0,
  0x91, 0xFB, 0x82, 0x50, 0x1C, 0xC0, 0x91, 0xFC, 0x82, 0x50, 0x1C, 0xA0, 0xD2, 0xFD, 0x84, 0x50,
  0x1C, 0xF3, 0x2F, 0xE8, 0x25, 0x01, 0x53, 0xFF, 0x05, 0x50, 0xDF, 0xF0, 0x54, 0x04, 0x0D, 0xFF,
  0x05, 0x77, 0x38, 0x17, 0xFD, 0x77, 0x40, 0x05, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_label_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_label_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_label_outline 24x24, 4-bit Alpha,  RLE, 69 bytes.
static const unsigned char ic_round_24_action_label_outline_data[] PROGMEM = {
  0x03, 0x0B, 0x80, 0x7D, 0x09, 0x02, 0x40, 0xCF, 0xE0, 0xE0, 0x13, 0xA0, 0x87, 0x38, 0x1B, 0xFA,
  0x3A, 0x74, 0x82, 0x1E, 0xF6, 0x2A, 0x75, 0x82, 0x5F, 0xE2, 0x1A, 0x76, 0x81, 0x9F, 0xC1, 0xA7,
  0x78, 0x1D, 0xF6, 0xA7, 0x78, 0x1C, 0xF7, 0xA7, 0x68, 0x18, 0xFD, 0x1A, 0x75, 0x03, 0xA0, 0x31,
  0xA7, 0x48, 0x21, 0xDF, 0x72, 0xA0, 0x67, 0x38, 0x1A, 0xFC, 0x30, 0xDF, 0xE0, 0xE0, 0x13, 0x04,
  0x0D, 0xFC, 0x0B, 0x03, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_label_outline() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 5, 21, 18), Box(0, 0, 23, 23),
      ic_round_24_action_label_outline_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_label 24x24, 4-bit Alpha,  RLE, 49 bytes.
static const unsigned char ic_round_24_action_label_data[] PROGMEM = {
  0x04, 0x0D, 0xFC, 0x0D, 0x04, 0x40, 0xDF, 0xE0, 0xE0, 0x23, 0xFF, 0x90, 0xC3, 0xFF, 0xA0, 0x82,
  0xFF, 0xB0, 0x31, 0xFF, 0xB0, 0xD1, 0xFF, 0xC0, 0x9F, 0xFC, 0x09, 0xFF, 0xB0, 0xD1, 0xFF, 0xB0,
  0x31, 0xFF, 0xA0, 0x82, 0xFF, 0x90, 0xC3, 0x0D, 0xFE, 0x0E, 0x02, 0x30, 0x40, 0xDF, 0xC0, 0xD0,
  0x44,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_label() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 5, 21, 18), Box(0, 0, 23, 23),
      ic_round_24_action_label_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_language 24x24, 4-bit Alpha,  RLE, 162 bytes.
static const unsigned char ic_round_24_action_language_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x50, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xA8, 0x6D, 0xDF,
  0xBB, 0xFD, 0xDA, 0x08, 0x50, 0x8A, 0x06, 0x01, 0xA0, 0x02, 0xA0, 0x10, 0x6A, 0x08, 0x30, 0x4A,
  0x83, 0x40, 0x7F, 0xA2, 0x83, 0xAF, 0x70, 0x4A, 0x04, 0x28, 0x1D, 0xF6, 0x28, 0x1C, 0xF4, 0x28,
  0x14, 0xFC, 0x28, 0x36, 0xFD, 0x05, 0xFF, 0xC0, 0x50, 0xAF, 0xFC, 0x82, 0x9D, 0xF3, 0x28, 0x16,
  0xF9, 0x48, 0x19, 0xF6, 0x28, 0x43, 0xFD, 0xEF, 0x12, 0x81, 0x7F, 0x84, 0x81, 0x8F, 0x72, 0x84,
  0x1F, 0xEE, 0xF1, 0x28, 0x17, 0xF8, 0x48, 0x18, 0xF7, 0x28, 0x41, 0xFE, 0xDF, 0x32, 0x81, 0x6F,
  0x94, 0x81, 0x9F, 0x62, 0x82, 0x3F, 0xDA, 0xFF, 0xC0, 0x90, 0x5F, 0xFC, 0x83, 0x50, 0xDF, 0x62,
  0x81, 0xCF, 0x42, 0x81, 0x4F, 0xC2, 0x81, 0x6F, 0xD2, 0x04, 0xA8, 0x34, 0x07, 0xFA, 0x28, 0x3A,
  0xF7, 0x04, 0xA0, 0x43, 0x08, 0xA0, 0x60, 0x1A, 0x00, 0x2A, 0x01, 0x06, 0xA0, 0x85, 0x08, 0xA8,
  0x6D, 0xDF, 0xBB, 0xFD, 0xDA, 0x08, 0x70, 0x50, 0xDF, 0x90, 0xD0, 0x47, 0x38, 0x65, 0x9D, 0xEE,
  0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_language() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_language_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_launch 24x24, 4-bit Alpha,  RLE, 82 bytes.
static const unsigned char ic_round_24_action_launch_data[] PROGMEM = {
  0x04, 0x0D, 0xE0, 0xB2, 0x0B, 0xE0, 0xDF, 0x0B, 0x20, 0xBF, 0x90, 0x37, 0x30, 0x10, 0xCD, 0x73,
  0x82, 0x1C, 0xFC, 0xC7, 0x28, 0x31, 0xCF, 0xC1, 0xC7, 0x18, 0x31, 0xCF, 0xC1, 0x1C, 0x78, 0x31,
  0xCF, 0xC1, 0x20, 0x0B, 0xA6, 0x83, 0x1C, 0xFC, 0x15, 0xA5, 0x83, 0x1C, 0xFC, 0x16, 0xA4, 0x83,
  0x1C, 0xFC, 0x15, 0x00, 0xBA, 0x38, 0x31, 0xCF, 0xC1, 0x6C, 0x38, 0x2A, 0xFC, 0x17, 0xC3, 0x81,
  0x6A, 0x17, 0x1C, 0x77, 0xC7, 0x7C, 0x03, 0x75, 0x03, 0xA0, 0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xF0,
  0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_launch() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_launch_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_leaderboard 24x24, 4-bit Alpha,  RLE, 100 bytes.
static const unsigned char ic_round_24_action_leaderboard_data[] PROGMEM = {
  0x70, 0x8C, 0x08, 0x77, 0x0B, 0xC0, 0xB7, 0x70, 0xBC, 0x0B, 0x77, 0x0B, 0xC0, 0xB7, 0x70, 0xBC,
  0x0B, 0x77, 0x0B, 0xC0, 0xB7, 0x0B, 0xC8, 0x14, 0x0B, 0xC0, 0xB7, 0xD8, 0x17, 0x0B, 0xC0, 0xB7,
  0xD8, 0x17, 0x0B, 0xC8, 0x1B, 0x04, 0xC0, 0xBD, 0x81, 0x70, 0xBC, 0x81, 0xB0, 0x7F, 0xB8, 0x17,
  0x0B, 0xC8, 0x1B, 0x07, 0xFB, 0x81, 0x70, 0xBC, 0x81, 0xB0, 0x7F, 0xB8, 0x17, 0x0B, 0xC8, 0x1B,
  0x07, 0xFB, 0x81, 0x70, 0xBC, 0x81, 0xB0, 0x7F, 0xB8, 0x17, 0x0B, 0xC8, 0x1B, 0x07, 0xFB, 0x81,
  0x70, 0xBC, 0x81, 0xB0, 0x7F, 0xB8, 0x17, 0x0B, 0xC8, 0x1B, 0x07, 0xD0, 0xBC, 0x81, 0x40, 0x8C,
  0x81, 0x80, 0x4C, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_leaderboard() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_leaderboard_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_lightbulb_circle 24x24, 4-bit Alpha,  RLE, 112 bytes.
static const unsigned char ic_round_24_action_lightbulb_circle_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8C, 0x0A, 0x03, 0x20, 0x30, 0xAC, 0x08, 0x30, 0x4C, 0x07, 0x60, 0x7C, 0x04, 0x20, 0xDB, 0x0A,
  0x71, 0x0A, 0xB8, 0x1D, 0x05, 0xC0, 0x37, 0x10, 0x3C, 0x05, 0x09, 0xC7, 0x3C, 0x09, 0x0D, 0xC7,
  0x3C, 0x0D, 0x0E, 0xC0, 0x47, 0x10, 0x4C, 0x00, 0xEC, 0x0B, 0x71, 0x0B, 0xC0, 0xE0, 0xDD, 0x07,
  0x60, 0x7D, 0x0D, 0x09, 0xFF, 0xC0, 0x90, 0x5E, 0x02, 0x40, 0x2E, 0x81, 0x50, 0xDD, 0x84, 0xA7,
  0x77, 0x7A, 0xD0, 0xD2, 0x04, 0xE8, 0x2B, 0x77, 0xBE, 0x04, 0x30, 0x8D, 0x82, 0xD2, 0x2D, 0xD0,
  0x85, 0x08, 0xFD, 0x08, 0x70, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x38, 0x65, 0x9D, 0xEE, 0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_lightbulb_circle() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_lightbulb_circle_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_lightbulb_outline 24x24, 4-bit Alpha,  RLE, 81 bytes.
static const unsigned char ic_round_24_action_lightbulb_outline_data[] PROGMEM = {
  0x38, 0x61, 0x7C, 0xEE, 0xC7, 0x15, 0x05, 0x0E, 0xE0, 0xE0, 0x53, 0x05, 0xA0, 0xA0, 0x32, 0x03,
  0x0A, 0xA8, 0x45, 0x01, 0xEF, 0x76, 0x85, 0x7F, 0xE1, 0x7F, 0xA7, 0x18, 0x4A, 0xF7, 0xCF, 0x37,
  0x18, 0x23, 0xFC, 0xE9, 0x73, 0x90, 0x0E, 0x97, 0x39, 0x82, 0xEC, 0xF4, 0x71, 0x84, 0x4F, 0xC7,
  0xFB, 0x71, 0x85, 0xBF, 0x71, 0xEF, 0x76, 0x84, 0x7F, 0xE1, 0x04, 0xA0, 0xA4, 0x0A, 0xA0, 0x43,
  0x04, 0xA4, 0xA0, 0x45, 0xA4, 0xA6, 0xF9, 0x60, 0xBE, 0x0B, 0x77, 0x77, 0x7E, 0x71, 0x0B, 0xC0,
  0xB4,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_lightbulb_outline() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 2, 18, 21), Box(0, 0, 23, 23),
      ic_round_24_action_lightbulb_outline_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_lightbulb 24x24, 4-bit Alpha,  RLE, 66 bytes.
static const unsigned char ic_round_24_action_lightbulb_data[] PROGMEM = {
  0x48, 0x61, 0x8C, 0xEE, 0xC8, 0x17, 0x07, 0xF9, 0x07, 0x50, 0x8F, 0xB0, 0x83, 0x04, 0xFD, 0x04,
  0x20, 0xDF, 0xD8, 0x1D, 0x03, 0xFF, 0x03, 0x06, 0xFF, 0x06, 0x07, 0xFF, 0x07, 0x06, 0xFF, 0x06,
  0x03, 0xFF, 0x81, 0x30, 0xDF, 0xD0, 0xD2, 0x04, 0xFD, 0x04, 0x30, 0x7F, 0xB0, 0x75, 0x07, 0xF9,
  0x06, 0x77, 0x72, 0x0B, 0xE0, 0xB7, 0x10, 0xBE, 0x0B, 0x77, 0x75, 0x0D, 0xA0, 0xD7, 0x58, 0x24,
  0xDD, 0x46,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_lightbulb() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_lightbulb_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_line_style 24x24, 4-bit Alpha,  RLE, 62 bytes.
static const unsigned char ic_round_24_action_line_style_data[] PROGMEM = {
  0x0B, 0xFF, 0xA0, 0xB8, 0x0C, 0x0F, 0x0B, 0xFF, 0xA0, 0xB8, 0x0C, 0x00, 0x0B, 0xE0, 0xB2, 0x0B,
  0xE0, 0x0B, 0xE0, 0xB2, 0x0B, 0xE0, 0xB8, 0x0C, 0x00, 0x0B, 0xB8, 0x1B, 0x04, 0xC8, 0x14, 0x0B,
  0xB0, 0x0B, 0xB8, 0x1B, 0x04, 0xC8, 0x14, 0x0B, 0xB0, 0xB8, 0x0C, 0x00, 0x00, 0xB2, 0x00, 0xB2,
  0x00, 0xB2, 0x00, 0xB2, 0x80, 0x0B, 0x20, 0x0B, 0x20, 0x0B, 0x20, 0x0B, 0x20, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_line_style() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 4, 20, 19), Box(0, 0, 23, 23),
      ic_round_24_action_line_style_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_line_weight 24x24, 4-bit Alpha,  RLE, 36 bytes.
static const unsigned char ic_round_24_action_line_weight_data[] PROGMEM = {
  0x0B, 0xFF, 0xA0, 0xB8, 0x0C, 0x0F, 0x0B, 0xFF, 0xA0, 0xB8, 0x0C, 0x00, 0x0B, 0xFF, 0xA0, 0xBF,
  0xFC, 0x0B, 0xFF, 0xA0, 0xB8, 0x0C, 0x00, 0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB8, 0x0C, 0x00,
  0x0D, 0xFF, 0xA0, 0xD0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_line_weight() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 4, 20, 19), Box(0, 0, 23, 23),
      ic_round_24_action_line_weight_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_list 24x24, 4-bit Alpha,  RLE, 32 bytes.
static const unsigned char ic_round_24_action_list_data[] PROGMEM = {
  0x00, 0xB2, 0x0B, 0xFD, 0x0F, 0xB2, 0x0B, 0xFD, 0x0B, 0x80, 0xC0, 0x00, 0x0B, 0x20, 0xBF, 0xD0,
  0xFB, 0x20, 0xBF, 0xD0, 0xB8, 0x0C, 0x00, 0x00, 0xB2, 0x0B, 0xFD, 0x0F, 0xB2, 0x0B, 0xFD, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_list() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 7, 20, 16), Box(0, 0, 23, 23),
      ic_round_24_action_list_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_lock_clock 24x24, 4-bit Alpha,  RLE, 116 bytes.
static const unsigned char ic_round_24_action_lock_clock_data[] PROGMEM = {
  0x58, 0x44, 0xBE, 0xEB, 0x47, 0x50, 0x8E, 0x08, 0x73, 0x04, 0xA8, 0x27, 0x11, 0x7A, 0x04, 0x72,
  0x81, 0xBF, 0x74, 0x81, 0x7F, 0xB7, 0x28, 0x1E, 0xF1, 0x48, 0x11, 0xFE, 0x72, 0xA6, 0xA7, 0x2A,
  0x6A, 0x60, 0x40, 0xDF, 0xD0, 0xD0, 0x43, 0x0D, 0xFF, 0x0D, 0x3F, 0xFA, 0x3F, 0xB8, 0x4E, 0x72,
  0x01, 0x33, 0xFA, 0x0A, 0x72, 0xF9, 0x0A, 0x28, 0x44, 0xBE, 0xEB, 0x42, 0xF0, 0xE2, 0x08, 0xE0,
  0x81, 0xF8, 0x17, 0x04, 0xB0, 0x80, 0x9B, 0x04, 0xF8, 0x12, 0x0B, 0xB0, 0x07, 0xB0, 0xBF, 0x20,
  0xEB, 0x00, 0x7B, 0x0E, 0xF2, 0x0E, 0xB8, 0x1C, 0x1B, 0xA0, 0xEF, 0x81, 0x20, 0xBC, 0x84, 0xB1,
  0xEF, 0xBD, 0xE8, 0x17, 0x04, 0xD0, 0xEA, 0x81, 0x44, 0xDD, 0x0E, 0x20, 0x8E, 0x08, 0x75, 0x84,
  0x4B, 0xEE, 0xB4, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_lock_clock() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_lock_clock_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_lock_open 24x24, 4-bit Alpha,  RLE, 75 bytes.
static const unsigned char ic_round_24_action_lock_open_data[] PROGMEM = {
  0x58, 0x43, 0xBE, 0xEB, 0x47, 0x20, 0x7E, 0x08, 0x70, 0x4A, 0x82, 0x71, 0x17, 0xA0, 0x46, 0x81,
  0xBF, 0x74, 0x81, 0x7F, 0xB6, 0x09, 0x0C, 0x58, 0x11, 0xFE, 0x77, 0xA7, 0x7A, 0x30, 0x40, 0xDF,
  0xD8, 0x1D, 0x4D, 0xFF, 0x0D, 0xA0, 0x37, 0x30, 0x3C, 0x75, 0xC7, 0x5C, 0x48, 0x24, 0xDD, 0x44,
  0xC4, 0x0D, 0xA0, 0xD4, 0xC4, 0x0D, 0xA0, 0xD4, 0xC4, 0x82, 0x4D, 0xD4, 0x4C, 0x75, 0xC7, 0x5C,
  0x03, 0x73, 0x03, 0xA0, 0xDF, 0xF8, 0x1D, 0x4D, 0xFD, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_lock_open() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 1, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_lock_open_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_lock_outline 24x24, 4-bit Alpha,  RLE, 77 bytes.
static const unsigned char ic_round_24_action_lock_outline_data[] PROGMEM = {
  0x58, 0x44, 0xBE, 0xEB, 0x47, 0x20, 0x8E, 0x08, 0x70, 0x4A, 0x82, 0x71, 0x17, 0xA0, 0x46, 0x81,
  0xBF, 0x74, 0x81, 0x7F, 0xB6, 0x81, 0xEF, 0x14, 0x81, 0x1F, 0xE6, 0xA6, 0xA6, 0xA6, 0xA3, 0x04,
  0x0D, 0xFD, 0x81, 0xD4, 0xDF, 0xF0, 0xDA, 0x03, 0x73, 0x03, 0xC7, 0x5C, 0x75, 0xC4, 0x82, 0x4D,
  0xD4, 0x4C, 0x40, 0xDA, 0x0D, 0x4C, 0x40, 0xDA, 0x0D, 0x4C, 0x48, 0x24, 0xDD, 0x44, 0xC7, 0x5C,
  0x75, 0xC0, 0x37, 0x30, 0x3A, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xD0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_lock_outline() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 1, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_lock_outline_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_lock_person 24x24, 4-bit Alpha,  RLE, 122 bytes.
static const unsigned char ic_round_24_action_lock_person_data[] PROGMEM = {
  0x58, 0x44, 0xBE, 0xEB, 0x47, 0x50, 0x8E, 0x08, 0x73, 0x82, 0x4F, 0xE5, 0x28, 0x25, 0xEF, 0x47,
  0x28, 0x1B, 0xF5, 0x48, 0x15, 0xFB, 0x72, 0x0E, 0x96, 0x90, 0xE7, 0x29, 0x0D, 0x60, 0xD9, 0x72,
  0x90, 0xD6, 0x0D, 0x96, 0x04, 0x0D, 0xFD, 0x0D, 0x04, 0x30, 0xDF, 0xF0, 0xD3, 0xFF, 0xA3, 0xFB,
  0x84, 0xE7, 0x20, 0x13, 0x3F, 0xA0, 0xA7, 0x2F, 0x90, 0xA2, 0x84, 0x4B, 0xEE, 0xB4, 0x2F, 0x0E,
  0x20, 0x8E, 0x08, 0x1F, 0x81, 0x70, 0x4A, 0x82, 0xD2, 0x2D, 0xA0, 0x4F, 0x81, 0x20, 0xBA, 0x08,
  0x20, 0x8A, 0x0B, 0xF2, 0x0E, 0xA8, 0x2D, 0x22, 0xDA, 0x0E, 0xF2, 0x0E, 0xF9, 0x0E, 0xF8, 0x93,
  0x20, 0xBF, 0xC4, 0x11, 0x4C, 0xFB, 0xDE, 0x81, 0x70, 0x4A, 0x82, 0x61, 0x16, 0xA8, 0x14, 0x4D,
  0xD0, 0xE2, 0x08, 0xE0, 0x87, 0x58, 0x44, 0xBE, 0xEB, 0x42,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_lock_person() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_lock_person_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_lock 24x24, 4-bit Alpha,  RLE, 65 bytes.
static const unsigned char ic_round_24_action_lock_data[] PROGMEM = {
  0x58, 0x44, 0xBE, 0xEB, 0x47, 0x20, 0x8E, 0x08, 0x70, 0x4A, 0x82, 0x71, 0x17, 0xA0, 0x46, 0x81,
  0xBF, 0x74, 0x81, 0x7F, 0xB6, 0x81, 0xEF, 0x14, 0x81, 0x1F, 0xE6, 0xA6, 0xA6, 0xA6, 0xA3, 0x04,
  0x0D, 0xFD, 0x81, 0xD4, 0xDF, 0xF0, 0xD8, 0x0E, 0x2F, 0x82, 0xB1, 0x1B, 0xFD, 0x01, 0x20, 0x1F,
  0xD0, 0x12, 0x01, 0xFD, 0x82, 0xB1, 0x1B, 0x80, 0xE2, 0xF0, 0xDF, 0xF8, 0x1D, 0x4D, 0xFD, 0x0D,
  0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_lock() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 1, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_lock_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_lock_reset 24x24, 4-bit Alpha,  RLE, 129 bytes.
static const unsigned char ic_round_24_action_lock_reset_data[] PROGMEM = {
  0x71, 0x86, 0x49, 0xDE, 0xFD, 0x93, 0x74, 0x02, 0x0B, 0xF9, 0x0B, 0x01, 0x71, 0x84, 0x3E, 0xFE,
  0x72, 0x28, 0x42, 0x7E, 0xFE, 0x36, 0x82, 0x2E, 0xFA, 0x78, 0x31, 0xBF, 0xE1, 0x58, 0x1B, 0xFA,
  0x73, 0x81, 0xBF, 0xB4, 0x81, 0x4F, 0xE4, 0x82, 0x4D, 0xD4, 0x38, 0x21, 0xEF, 0x33, 0x81, 0x9F,
  0x74, 0x82, 0xD3, 0x3D, 0x48, 0x17, 0xF9, 0x38, 0x1D, 0xF2, 0x49, 0x29, 0x48, 0x13, 0xFD, 0x30,
  0xE9, 0x40, 0xBC, 0x0B, 0x49, 0x0E, 0x02, 0xE0, 0x21, 0xE4, 0x98, 0x1E, 0x07, 0xC0, 0x72, 0xE3,
  0x81, 0x2F, 0xD2, 0x07, 0xA0, 0x73, 0xE3, 0x81, 0x7F, 0x93, 0x00, 0x74, 0x0B, 0xC0, 0xB3, 0x81,
  0xEF, 0x47, 0x73, 0x81, 0xAF, 0xB7, 0x04, 0x07, 0x71, 0x82, 0xAF, 0xE2, 0x78, 0x3B, 0xFE, 0x72,
  0x28, 0x42, 0x7E, 0xFE, 0x37, 0x10, 0x20, 0xBF, 0x90, 0xB0, 0x27, 0x48, 0x64, 0x9D, 0xFE, 0xD9,
  0x45,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_lock_reset() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_lock_reset_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_login 24x24, 4-bit Alpha,  RLE, 68 bytes.
static const unsigned char ic_round_24_action_login_data[] PROGMEM = {
  0x73, 0x0B, 0xF0, 0xD0, 0x47, 0x30, 0xBF, 0x90, 0xD7, 0x74, 0xA7, 0x74, 0xA7, 0x10, 0x05, 0x71,
  0xA7, 0x18, 0x1D, 0xF7, 0x7A, 0x71, 0x04, 0xA0, 0x76, 0xA7, 0x20, 0x4A, 0x07, 0x5A, 0x0B, 0xFD,
  0x05, 0x4A, 0x0B, 0xFD, 0x05, 0x4A, 0x72, 0x04, 0xA0, 0x75, 0xA7, 0x10, 0x4A, 0x07, 0x6A, 0x71,
  0x81, 0xDF, 0x77, 0xA7, 0x10, 0x05, 0x71, 0xA7, 0x74, 0xA7, 0x74, 0xA7, 0x30, 0xBF, 0x90, 0xD7,
  0x30, 0xBF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_login() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_login_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_logout 24x24, 4-bit Alpha,  RLE, 56 bytes.
static const unsigned char ic_round_24_action_logout_data[] PROGMEM = {
  0x04, 0x0D, 0xE0, 0xB7, 0x20, 0xDF, 0x0B, 0x72, 0xA7, 0x72, 0xA7, 0x72, 0xA7, 0x72, 0xA7, 0x50,
  0x23, 0xA7, 0x59, 0x07, 0x2A, 0x75, 0xA0, 0x71, 0xA4, 0x0B, 0xFB, 0x07, 0xA4, 0x0B, 0xFB, 0x07,
  0xA7, 0x5A, 0x07, 0x1A, 0x75, 0x90, 0x72, 0xA7, 0x50, 0x23, 0xA7, 0x72, 0xA7, 0x72, 0xA7, 0x72,
  0x0D, 0xF0, 0xB7, 0x20, 0x40, 0xDE, 0x0B, 0x72,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_logout() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_logout_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_loyalty 24x24, 4-bit Alpha,  RLE, 108 bytes.
static const unsigned char ic_round_24_action_loyalty_data[] PROGMEM = {
  0x04, 0x0D, 0xF0, 0xD0, 0x47, 0x20, 0xDF, 0xB0, 0x57, 0x1A, 0x81, 0x70, 0x7F, 0x05, 0x7A, 0x3F,
  0x90, 0x56, 0xA8, 0x17, 0x07, 0xFA, 0x05, 0x5F, 0xF9, 0x05, 0x4F, 0xFA, 0x05, 0x3F, 0xFB, 0x05,
  0x2F, 0xFC, 0x81, 0x50, 0xDD, 0x89, 0x0D, 0x30, 0x4D, 0xD4, 0x04, 0xDB, 0x00, 0x4D, 0x03, 0x30,
  0x01, 0x30, 0x4B, 0x81, 0xD0, 0x5C, 0x73, 0xB0, 0xD2, 0x05, 0xB0, 0x37, 0x10, 0x4B, 0x04, 0x30,
  0x5A, 0x0D, 0x01, 0x60, 0x10, 0xDA, 0x05, 0x50, 0x5A, 0x0D, 0x01, 0x40, 0x10, 0xDA, 0x05, 0x70,
  0x5A, 0x0D, 0x01, 0x20, 0x10, 0xDA, 0x05, 0x72, 0x05, 0xA8, 0x2D, 0x11, 0xDA, 0x05, 0x74, 0x05,
  0xA0, 0x0D, 0xA0, 0x57, 0x60, 0x5C, 0x05, 0x77, 0x18, 0x24, 0xDD, 0x47,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_loyalty() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_loyalty_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_manage_accounts 24x24, 4-bit Alpha,  RLE, 108 bytes.
static const unsigned char ic_round_24_action_manage_accounts_data[] PROGMEM = {
  0x58, 0x41, 0xAD, 0xDA, 0x17, 0x60, 0x10, 0xEC, 0x0E, 0x01, 0x75, 0x0A, 0xE0, 0xA7, 0x50, 0xDE,
  0x0D, 0x75, 0x0D, 0xE0, 0xD7, 0x50, 0xAE, 0x0A, 0x75, 0x01, 0x0E, 0xC0, 0xE0, 0x17, 0x68, 0x41,
  0xAD, 0xDA, 0x12, 0x82, 0x1E, 0xE1, 0x77, 0x81, 0x20, 0x7A, 0x81, 0x70, 0x24, 0x89, 0x02, 0x7B,
  0xDF, 0x70, 0x4F, 0xEC, 0x84, 0xEF, 0x50, 0x3B, 0xD8, 0x13, 0x07, 0xA8, 0x2B, 0x11, 0xBA, 0x08,
  0x05, 0xF3, 0x81, 0xBF, 0x12, 0x83, 0x1F, 0xC0, 0xDF, 0x38, 0x1B, 0xF1, 0x28, 0x11, 0xFC, 0x1F,
  0x98, 0x12, 0x07, 0xA8, 0x2B, 0x11, 0xBA, 0x08, 0xF9, 0x83, 0x70, 0x4F, 0xEC, 0x82, 0xEF, 0x5B,
  0xF0, 0xE2, 0x81, 0x20, 0x7A, 0x81, 0x70, 0x27, 0x78, 0x21, 0xEE, 0x13,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_manage_accounts() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_manage_accounts_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_manage_history 24x24, 4-bit Alpha,  RLE, 157 bytes.
static const unsigned char ic_round_24_action_manage_history_data[] PROGMEM = {
  0x58, 0x63, 0x9C, 0xEE, 0xD9, 0x47, 0x18, 0x3B, 0xB0, 0x2B, 0xF9, 0x0B, 0x02, 0x6A, 0x89, 0x43,
  0xEF, 0xE8, 0x21, 0x02, 0x7E, 0xFE, 0x35, 0xA8, 0x2E, 0xFA, 0x17, 0x82, 0xAF, 0xE2, 0x4B, 0x0A,
  0x40, 0x0B, 0x48, 0x1A, 0xFB, 0x4D, 0x0B, 0x2A, 0x58, 0x1E, 0xF4, 0x30, 0xBC, 0x0B, 0x2A, 0x58,
  0x17, 0xF9, 0x74, 0xA5, 0x81, 0x2F, 0xD7, 0x4A, 0x01, 0x59, 0x0E, 0x74, 0x82, 0xBF, 0xC1, 0x72,
  0x81, 0x7D, 0x15, 0x82, 0x1C, 0xF2, 0x72, 0x81, 0x9F, 0x86, 0x01, 0x06, 0x38, 0x21, 0xEE, 0x13,
  0x82, 0x4F, 0xE1, 0x71, 0x81, 0x20, 0x7A, 0x81, 0x70, 0x22, 0x81, 0xBF, 0xB7, 0x81, 0x4F, 0xEC,
  0x87, 0xEF, 0x50, 0x2E, 0xFA, 0x15, 0x07, 0xA8, 0x2B, 0x11, 0xBA, 0x08, 0x28, 0x43, 0xEF, 0xE8,
  0x34, 0x81, 0xBF, 0x12, 0x81, 0x1F, 0xC4, 0x02, 0x0B, 0xB0, 0x33, 0x81, 0xBF, 0x12, 0x81, 0x1F,
  0xC6, 0x82, 0x49, 0xDB, 0x20, 0x7A, 0x82, 0xB1, 0x1B, 0xA0, 0x87, 0x48, 0x14, 0xFE, 0xC8, 0x1E,
  0xF5, 0x75, 0x81, 0x20, 0x7A, 0x81, 0x70, 0x27, 0x71, 0x82, 0x1E, 0xE1, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_manage_history() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 23, 23), Box(0, 0, 23, 23),
      ic_round_24_action_manage_history_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_mark_as_unread 24x24, 4-bit Alpha,  RLE, 110 bytes.
static const unsigned char ic_round_24_action_mark_as_unread_data[] PROGMEM = {
  0x68, 0x21, 0x7B, 0x77, 0x78, 0x11, 0x7E, 0xB0, 0xE0, 0x77, 0x38, 0x92, 0x17, 0xEF, 0xE8, 0x28,
  0xEF, 0xE7, 0x70, 0x80, 0xEA, 0x08, 0x01, 0x30, 0x10, 0x8A, 0x0E, 0x06, 0x40, 0xBA, 0x09, 0x01,
  0x70, 0x10, 0x9A, 0x09, 0x3A, 0x02, 0x77, 0x3A, 0x10, 0x40, 0xDF, 0xE0, 0xD0, 0x4A, 0x10, 0xDF,
  0xF9, 0x0D, 0xA1, 0xA0, 0xB0, 0xCF, 0xA0, 0xC0, 0xBC, 0x1A, 0x82, 0x10, 0x4C, 0xD8, 0x2C, 0x40,
  0x1C, 0x1A, 0x0B, 0x03, 0x28, 0x34, 0xCF, 0xC4, 0x20, 0x30, 0xBC, 0x1C, 0x0B, 0x03, 0x20, 0x32,
  0x03, 0x0B, 0xE1, 0xE8, 0x3A, 0x20, 0x2A, 0xE0, 0xD9, 0x1F, 0x90, 0xCF, 0x90, 0x40, 0xD1, 0xFF,
  0xB3, 0xFF, 0xB3, 0xFF, 0xB3, 0x0D, 0xFF, 0x90, 0xD3, 0x04, 0x0D, 0xFE, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_mark_as_unread() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_mark_as_unread_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_markunread_mailbox 24x24, 4-bit Alpha,  RLE, 43 bytes.
static const unsigned char ic_round_24_action_markunread_mailbox_data[] PROGMEM = {
  0x40, 0xBE, 0x0B, 0x75, 0xF9, 0x75, 0xF9, 0x75, 0xF0, 0xB7, 0x5A, 0x77, 0x4A, 0x77, 0x04, 0x0D,
  0xC2, 0xFB, 0x81, 0xD4, 0xDD, 0x2F, 0xC0, 0xDE, 0x2F, 0xFC, 0x2F, 0xFC, 0x2F, 0xFC, 0x00, 0x38,
  0x0A, 0xD0, 0xF0, 0xDF, 0xFC, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_markunread_mailbox() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 0, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_markunread_mailbox_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_maximize 24x24, 4-bit Alpha,  RLE, 7 bytes.
static const unsigned char ic_round_24_action_maximize_data[] PROGMEM = {
  0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_maximize() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 4), Box(0, 0, 23, 23),
      ic_round_24_action_maximize_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_mediation 24x24, 4-bit Alpha,  RLE, 114 bytes.
static const unsigned char ic_round_24_action_mediation_data[] PROGMEM = {
  0x18, 0x28, 0xDE, 0x87, 0x71, 0x08, 0xC0, 0x87, 0x70, 0xDC, 0x0D, 0x77, 0x0E, 0xD0, 0xB0, 0x17,
  0x50, 0x8E, 0x0E, 0x03, 0x75, 0x87, 0x8E, 0xE8, 0x1A, 0xFE, 0x27, 0x73, 0x81, 0xAF, 0xA7, 0x73,
  0x82, 0x1E, 0xF3, 0x50, 0x24, 0x82, 0x8D, 0xE8, 0x38, 0x17, 0xF8, 0x59, 0x07, 0x20, 0x8C, 0x08,
  0x28, 0x13, 0xFC, 0x5A, 0x81, 0x70, 0xDF, 0xFC, 0x07, 0x0E, 0xFF, 0xC0, 0x70, 0x8C, 0x08, 0x28,
  0x13, 0xFC, 0x5A, 0x07, 0x28, 0x28, 0xEE, 0x83, 0x81, 0x7F, 0x85, 0x90, 0x77, 0x28, 0x21, 0xEF,
  0x35, 0x02, 0x73, 0x81, 0xAF, 0xB7, 0x48, 0x78, 0xDE, 0x71, 0xAF, 0xE2, 0x73, 0x08, 0xE0, 0xE0,
  0x37, 0x40, 0xDD, 0x0B, 0x01, 0x75, 0x0E, 0xC0, 0xD7, 0x70, 0x8C, 0x08, 0x77, 0x18, 0x28, 0xED,
  0x87, 0x71,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_mediation() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 1, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_mediation_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_minimize 24x24, 4-bit Alpha,  RLE, 6 bytes.
static const unsigned char ic_round_24_action_minimize_data[] PROGMEM = {
  0x0B, 0xFB, 0x00, 0xBF, 0xB0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_minimize() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(6, 19, 17, 20), Box(0, 0, 23, 23),
      ic_round_24_action_minimize_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_model_training 24x24, 4-bit Alpha,  RLE, 126 bytes.
static const unsigned char ic_round_24_action_model_training_data[] PROGMEM = {
  0x72, 0x02, 0x77, 0x39, 0x07, 0x77, 0x2A, 0x07, 0x74, 0x82, 0x49, 0xDE, 0xB0, 0x77, 0x10, 0x20,
  0xBF, 0x07, 0x78, 0x43, 0xEF, 0xB5, 0x11, 0xA0, 0x72, 0x04, 0x02, 0x38, 0x22, 0xEF, 0x64, 0x90,
  0x73, 0x90, 0xE0, 0x22, 0x81, 0xBF, 0x75, 0x02, 0x48, 0x5A, 0xFB, 0x04, 0xFE, 0x75, 0x84, 0xEF,
  0x49, 0xF7, 0x38, 0x41, 0x9D, 0xD9, 0x13, 0x84, 0x7F, 0x9D, 0xF3, 0x30, 0xCC, 0x0C, 0x38, 0x42,
  0xFD, 0xEF, 0x12, 0x04, 0xE0, 0x43, 0x98, 0x2E, 0xEF, 0x12, 0x07, 0xE0, 0x62, 0x84, 0x1F, 0xED,
  0xF3, 0x20, 0x4E, 0x03, 0x28, 0x43, 0xFD, 0x9F, 0x73, 0x0B, 0xC0, 0xB3, 0x84, 0x8F, 0x94, 0xFE,
  0x30, 0x10, 0xEA, 0x0E, 0x01, 0x38, 0x5E, 0xF4, 0x0B, 0xF2, 0x30, 0x5A, 0x05, 0x38, 0x12, 0xFB,
  0x20, 0x10, 0x35, 0x00, 0x75, 0x03, 0x01, 0x72, 0x00, 0x77, 0x72, 0x00, 0xB7, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_model_training() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 1, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_model_training_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_network_ping 24x24, 4-bit Alpha,  RLE, 74 bytes.
static const unsigned char ic_round_24_action_network_ping_data[] PROGMEM = {
  0x01, 0x06, 0x76, 0x86, 0x1B, 0xEB, 0x17, 0xFB, 0x75, 0x0B, 0xB8, 0x3B, 0x1D, 0xFB, 0x74, 0x0E,
  0xB8, 0x4E, 0x01, 0xDF, 0xB7, 0x30, 0xEB, 0x0B, 0x28, 0x21, 0xDF, 0xB7, 0x18, 0x4B, 0xFE, 0xEB,
  0x13, 0x82, 0x1D, 0xFB, 0x68, 0x2B, 0xFD, 0x17, 0x82, 0x1D, 0xFB, 0x48, 0x2B, 0xFD, 0x17, 0x28,
  0x21, 0xDF, 0xB2, 0x82, 0xBF, 0xD1, 0x74, 0x86, 0x1D, 0xFB, 0xBF, 0xD1, 0x76, 0x01, 0x0D, 0xA0,
  0xD0, 0x17, 0x20, 0xBF, 0xF0, 0xB4, 0x0B, 0xFF, 0x0B, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_network_ping() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 6, 21, 17), Box(0, 0, 23, 23),
      ic_round_24_action_network_ping_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_new_label 24x24, 4-bit Alpha,  RLE, 64 bytes.
static const unsigned char ic_round_24_action_new_label_data[] PROGMEM = {
  0x10, 0x40, 0xDF, 0xB0, 0xD0, 0x45, 0x0D, 0xFD, 0x0E, 0x02, 0x4F, 0xF0, 0xC4, 0xFF, 0x90, 0x83,
  0xFF, 0xA0, 0x35, 0x01, 0x07, 0xFC, 0x0D, 0x70, 0x7F, 0xC0, 0x63, 0x82, 0xBB, 0x01, 0xFC, 0x06,
  0x3A, 0x20, 0x10, 0x7F, 0x90, 0xD4, 0xA4, 0x07, 0xF8, 0x13, 0x0B, 0xE8, 0x1B, 0x01, 0xE0, 0x82,
  0x0B, 0xE0, 0xB2, 0xD0, 0xC6, 0xA5, 0xC0, 0xE0, 0x26, 0xA5, 0xB0, 0xD0, 0x47, 0x00, 0xB7, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_new_label() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 5, 20, 19), Box(0, 0, 23, 23),
      ic_round_24_action_new_label_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_next_plan 24x24, 4-bit Alpha,  RLE, 106 bytes.
static const unsigned char ic_round_24_action_next_plan_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFF, 0xA0, 0x42, 0x0D, 0xFF, 0xA8, 0x1D, 0x05, 0xFF, 0xC0, 0x50, 0x9D,
  0x85, 0xD5, 0x20, 0x15, 0xCA, 0x07, 0xB0, 0x90, 0xDC, 0x89, 0x08, 0x18, 0xDF, 0xD8, 0x18, 0x71,
  0xB0, 0xD0, 0xEB, 0x81, 0xA1, 0xDD, 0x0D, 0x01, 0x2B, 0x00, 0xEB, 0x02, 0x0C, 0xE0, 0x73, 0xB0,
  0xE0, 0xDA, 0x0D, 0x05, 0xE0, 0x74, 0xB0, 0xD0, 0x9F, 0xFC, 0x09, 0x05, 0xFF, 0xC8, 0x15, 0x0D,
  0xFF, 0xA0, 0xD2, 0x04, 0xFF, 0xA0, 0x43, 0x08, 0xFF, 0x08, 0x50, 0x8F, 0xD0, 0x87, 0x04, 0x0D,
  0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_next_plan() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_next_plan_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_nightlight_round 24x24, 4-bit Alpha,  RLE, 74 bytes.
static const unsigned char ic_round_24_action_nightlight_round_data[] PROGMEM = {
  0x68, 0x41, 0x7B, 0xDF, 0x55, 0x09, 0xC0, 0xE0, 0x33, 0x02, 0x0D, 0xC0, 0xD0, 0x23, 0x02, 0x0E,
  0xC0, 0xD0, 0x14, 0x0C, 0xD0, 0x34, 0x06, 0xD0, 0x95, 0x0D, 0xD0, 0x34, 0x02, 0xD0, 0xD5, 0x05,
  0xD0, 0xA5, 0x06, 0xD0, 0x85, 0x07, 0xD0, 0x85, 0x05, 0xD0, 0xA5, 0x02, 0xD0, 0xD6, 0x0C, 0xD0,
  0x35, 0x06, 0xD0, 0x96, 0x0C, 0xD0, 0x35, 0x02, 0x0E, 0xC0, 0xD0, 0x15, 0x02, 0x0D, 0xC0, 0xD0,
  0x25, 0x01, 0x09, 0xC0, 0xE0, 0x36, 0x84, 0x27, 0xBD, 0xF5,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_nightlight_round() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 2, 16, 21), Box(0, 0, 23, 23),
      ic_round_24_action_nightlight_round_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_no_accounts 24x24, 4-bit Alpha,  RLE, 152 bytes.
static const unsigned char ic_round_24_action_no_accounts_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x12, 0x6C, 0xA0, 0x85, 0x08, 0xA0, 0x77, 0x10, 0x6A, 0x08, 0x30, 0x4B, 0x86, 0xC1, 0x02,
  0xED, 0x91, 0x20, 0x4A, 0x04, 0x28, 0x7D, 0xF7, 0xCF, 0xC1, 0x04, 0xA0, 0xC3, 0x89, 0x56, 0xFD,
  0x05, 0xFC, 0x01, 0xCF, 0xC1, 0x04, 0xA0, 0x43, 0x84, 0xCF, 0x59, 0xF6, 0x28, 0x71, 0xCF, 0xC1,
  0x04, 0xF7, 0x38, 0x46, 0xF9, 0xDF, 0x23, 0x04, 0xA8, 0x3C, 0x10, 0x44, 0x38, 0x22, 0xFD, 0xE9,
  0x50, 0xCA, 0x0C, 0x01, 0x69, 0x00, 0xE9, 0x68, 0x39, 0xEF, 0xC1, 0x59, 0x82, 0xED, 0xF2, 0x68,
  0x31, 0xCF, 0xC1, 0x38, 0x42, 0xFD, 0x9F, 0x67, 0x83, 0x1C, 0xFC, 0x12, 0x84, 0x6F, 0x95, 0xFC,
  0x38, 0x15, 0x9D, 0x0F, 0xEA, 0x89, 0x2C, 0x10, 0xCF, 0x50, 0xDF, 0x64, 0xDF, 0xA8, 0x2C, 0x7F,
  0xD2, 0x04, 0xFF, 0xA0, 0x43, 0x08, 0xFF, 0x08, 0x50, 0x8F, 0xD0, 0x87, 0x04, 0x0D, 0xF9, 0x0D,
  0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_no_accounts() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_no_accounts_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_noise_aware 24x24, 4-bit Alpha,  RLE, 134 bytes.
static const unsigned char ic_round_24_action_noise_aware_data[] PROGMEM = {
  0x72, 0x00, 0xB7, 0x70, 0xB0, 0xE2, 0x00, 0xB2, 0x0D, 0x0A, 0x73, 0x08, 0x0A, 0x60, 0xA0, 0x87,
  0x00, 0x57, 0x50, 0x50, 0x64, 0x0E, 0x0D, 0x38, 0x37, 0xDF, 0xD7, 0x40, 0xD0, 0xE4, 0x00, 0x22,
  0x0B, 0xD0, 0xB3, 0x00, 0x27, 0x87, 0x7F, 0xD4, 0x03, 0xDF, 0x76, 0x81, 0x7D, 0x12, 0x81, 0xDF,
  0x43, 0x81, 0x3E, 0x63, 0x84, 0x1D, 0x87, 0xD1, 0x2A, 0x73, 0x81, 0x1D, 0x85, 0x81, 0xDF, 0x32,
  0x81, 0x8E, 0x87, 0x58, 0x67, 0xFD, 0x10, 0xEF, 0xE7, 0x81, 0x8D, 0x13, 0x85, 0xCF, 0xC1, 0x8E,
  0x84, 0x84, 0x1D, 0x78, 0xD1, 0x38, 0x21, 0xCF, 0xA7, 0x81, 0x1D, 0x77, 0x85, 0x1E, 0xF3, 0x3E,
  0x77, 0x10, 0x20, 0x34, 0x08, 0xC0, 0x82, 0x00, 0x24, 0x0E, 0x0D, 0x58, 0x28, 0xEE, 0x83, 0x0D,
  0x0E, 0x40, 0x60, 0x57, 0x50, 0x05, 0x70, 0x80, 0xA6, 0x0A, 0x08, 0x73, 0x0A, 0x0D, 0x20, 0x0B,
  0x20, 0xE0, 0xB7, 0x70, 0x0B, 0x72,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_noise_aware() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_noise_aware_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_noise_control_off 24x24, 4-bit Alpha,  RLE, 135 bytes.
static const unsigned char ic_round_24_action_noise_control_off_data[] PROGMEM = {
  0x68, 0x64, 0x9C, 0xEE, 0xC9, 0x47, 0x40, 0xAF, 0x90, 0x97, 0x38, 0x26, 0xB6, 0x22, 0x82, 0x27,
  0xB6, 0x77, 0x77, 0x48, 0x37, 0xDF, 0xD7, 0x72, 0x0A, 0x06, 0x30, 0xBD, 0x0B, 0x48, 0x46, 0xA0,
  0x4F, 0xB2, 0x87, 0x7F, 0xD4, 0x03, 0xDF, 0x73, 0x84, 0xBF, 0x4A, 0xF6, 0x28, 0x1D, 0xF4, 0x38,
  0x13, 0xE6, 0x38, 0x46, 0xFA, 0xCF, 0x22, 0xA7, 0x38, 0x22, 0xFC, 0xE9, 0x38, 0x1D, 0xF3, 0x28,
  0x18, 0xE8, 0x59, 0x00, 0xE9, 0x38, 0x67, 0xFD, 0x10, 0xEF, 0xE5, 0x98, 0x2E, 0xCF, 0x23, 0x85,
  0xCF, 0xC1, 0x8E, 0x84, 0x84, 0x2F, 0xCA, 0xF6, 0x38, 0x21, 0xCF, 0xA7, 0x84, 0x6F, 0xA4, 0xFB,
  0x48, 0x51, 0xEF, 0x33, 0xD7, 0x38, 0x4B, 0xF4, 0x0A, 0x65, 0x08, 0xC0, 0x83, 0x06, 0x0A, 0x73,
  0x82, 0x8E, 0xE8, 0x77, 0x77, 0x48, 0x26, 0xB7, 0x22, 0x82, 0x26, 0xB6, 0x73, 0x09, 0xF9, 0x0A,
  0x74, 0x86, 0x49, 0xCE, 0xEC, 0x94, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_noise_control_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_noise_control_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_not_accessible 24x24, 4-bit Alpha,  RLE, 135 bytes.
static const unsigned char ic_round_24_action_not_accessible_data[] PROGMEM = {
  0x72, 0x82, 0x4D, 0xD4, 0x71, 0x09, 0x06, 0x60, 0xDA, 0x0D, 0x70, 0x1A, 0x07, 0x50, 0xDA, 0x0D,
  0x71, 0x05, 0xA0, 0x74, 0x82, 0x4D, 0xD4, 0x72, 0x05, 0xA0, 0x77, 0x73, 0x05, 0xA0, 0x72, 0x82,
  0x2D, 0xD5, 0x74, 0x05, 0xA0, 0x72, 0x08, 0xA0, 0x57, 0x40, 0x5A, 0x07, 0x20, 0x8A, 0x05, 0x74,
  0x05, 0xA0, 0x72, 0x08, 0xA0, 0xA0, 0x37, 0x30, 0x5A, 0x07, 0x20, 0x50, 0xEA, 0x0C, 0x71, 0x81,
  0x4A, 0x5A, 0x07, 0x28, 0x21, 0x6B, 0xA7, 0x07, 0xA1, 0xB0, 0x77, 0x40, 0x3A, 0x07, 0x1C, 0x07,
  0x73, 0x81, 0xBF, 0x72, 0x0D, 0xC0, 0x77, 0x28, 0x1E, 0xF1, 0x20, 0x40, 0xDC, 0x07, 0x71, 0x81,
  0xEF, 0x16, 0x05, 0xA0, 0x77, 0x81, 0xBF, 0x74, 0x82, 0x6F, 0xA5, 0xA0, 0x76, 0x04, 0xA8, 0x27,
  0x11, 0x7A, 0x81, 0x40, 0x5A, 0x07, 0x60, 0x8E, 0x07, 0x30, 0x5A, 0x06, 0x68, 0x44, 0xBE, 0xEB,
  0x35, 0x81, 0x5F, 0x97, 0x74, 0x01, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_not_accessible() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 20, 22), Box(0, 0, 23, 23),
      ic_round_24_action_not_accessible_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_note_add 24x24, 4-bit Alpha,  RLE, 63 bytes.
static const unsigned char ic_round_24_action_note_add_data[] PROGMEM = {
  0x04, 0x0D, 0xF0, 0xE0, 0x65, 0x0D, 0xF9, 0x81, 0xDF, 0x74, 0xFA, 0x82, 0x1D, 0xF7, 0x3F, 0xA1,
  0x82, 0x1D, 0xF7, 0x2F, 0xA2, 0x82, 0x1D, 0xF7, 0x1F, 0xA3, 0x82, 0x1D, 0xF6, 0xFA, 0x03, 0x38,
  0x11, 0xDE, 0x80, 0xC3, 0xF0, 0x03, 0xFF, 0x2F, 0xF2, 0xFC, 0x03, 0x60, 0x3F, 0x90, 0x36, 0x03,
  0xFC, 0x2F, 0xF2, 0xFF, 0x00, 0x3F, 0xFF, 0xA0, 0xDF, 0xF8, 0x1D, 0x4D, 0xFD, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_note_add() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_note_add_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_not_started 24x24, 4-bit Alpha,  RLE, 101 bytes.
static const unsigned char ic_round_24_action_not_started_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFF, 0xA0, 0x42, 0x0D, 0xFF, 0xA8, 0x1D, 0x05, 0xE0, 0x03, 0xFB, 0x05,
  0x09, 0xE2, 0x98, 0x15, 0x4D, 0xE0, 0x90, 0xDE, 0x29, 0x20, 0x10, 0xCD, 0x0D, 0x0E, 0xE2, 0x94,
  0x0C, 0xC0, 0x0E, 0xE2, 0x94, 0x0C, 0xC0, 0xE0, 0xDE, 0x29, 0x20, 0x10, 0xCD, 0x0D, 0x09, 0xE2,
  0x98, 0x15, 0x4D, 0xE0, 0x90, 0x5E, 0x00, 0x3F, 0xB8, 0x15, 0x0D, 0xFF, 0xA0, 0xD2, 0x04, 0xFF,
  0xA0, 0x43, 0x08, 0xFF, 0x08, 0x50, 0x8F, 0xD0, 0x87, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86,
  0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_not_started() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_not_started_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_offline_bolt 24x24, 4-bit Alpha,  RLE, 109 bytes.
static const unsigned char ic_round_24_action_offline_bolt_data[] PROGMEM = {
  0x68, 0x64, 0x9C, 0xEE, 0xC9, 0x47, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x07, 0xFD, 0x07, 0x50,
  0x7F, 0x0A, 0xE0, 0x73, 0x04, 0xF0, 0xB1, 0xF0, 0x42, 0x0D, 0xF0, 0x31, 0xF8, 0x1D, 0x04, 0xF0,
  0xA2, 0xF9, 0x04, 0x09, 0xF0, 0x22, 0xF9, 0x09, 0x0C, 0xE0, 0xA3, 0x81, 0x33, 0x5D, 0x0C, 0x0E,
  0xE0, 0x25, 0x04, 0xD0, 0x0E, 0xD0, 0x96, 0x0B, 0xD0, 0xE0, 0xCD, 0x82, 0x93, 0x31, 0x20, 0x4E,
  0x0C, 0x09, 0xF9, 0x07, 0x20, 0xBE, 0x09, 0x04, 0xF9, 0x81, 0x70, 0x4F, 0x81, 0x40, 0xDF, 0x81,
  0x70, 0xBE, 0x0D, 0x20, 0x4F, 0x07, 0x04, 0xF0, 0x43, 0x07, 0xE0, 0x0D, 0xE0, 0x75, 0x07, 0xFD,
  0x07, 0x70, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x38, 0x64, 0x9C, 0xEE, 0xC9, 0x46,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_offline_bolt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_offline_bolt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_offline_pin 24x24, 4-bit Alpha,  RLE, 114 bytes.
static const unsigned char ic_round_24_action_offline_pin_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFB, 0x81, 0xD6, 0xCB, 0x04, 0x20, 0xDF, 0xA8, 0x2D, 0x10, 0x8B, 0x81,
  0xD0, 0x5F, 0xA8, 0x3D, 0x10, 0x3E, 0xC0, 0x50, 0x9D, 0x0C, 0xA8, 0x3D, 0x10, 0x3E, 0xD0, 0x90,
  0xDC, 0x86, 0x80, 0x6D, 0x10, 0x3E, 0xE0, 0xD0, 0xEC, 0x0C, 0x40, 0x30, 0xEF, 0x00, 0xED, 0x0B,
  0x20, 0x30, 0xEF, 0x90, 0xE0, 0xDE, 0x81, 0xC8, 0xEF, 0xA0, 0xD0, 0x9F, 0xFC, 0x09, 0x05, 0xFF,
  0xC8, 0x15, 0x0D, 0xB0, 0x37, 0x10, 0x3B, 0x0D, 0x20, 0x4B, 0x03, 0x71, 0x03, 0xB0, 0x43, 0x08,
  0xFF, 0x08, 0x50, 0x8F, 0xD0, 0x87, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED,
  0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_offline_pin() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_offline_pin_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_on_device_training 24x24, 4-bit Alpha,  RLE, 88 bytes.
static const unsigned char ic_round_24_action_on_device_training_data[] PROGMEM = {
  0x04, 0x0D, 0xFD, 0x81, 0xD4, 0xDF, 0xF0, 0xD8, 0x0D, 0x6F, 0x75, 0xC6, 0x0B, 0x01, 0x4C, 0x38,
  0x34, 0xBE, 0xFD, 0x4C, 0x28, 0x48, 0xFD, 0x9F, 0x64, 0xC1, 0x81, 0x4F, 0x92, 0x03, 0x20, 0x40,
  0x21, 0xC1, 0x89, 0x0B, 0xD0, 0x4E, 0xD4, 0x0C, 0xB1, 0xC1, 0x82, 0xE9, 0x0D, 0xA8, 0x2D, 0x08,
  0xE1, 0xC1, 0x82, 0xE8, 0x0D, 0xA8, 0x2D, 0x08, 0xE1, 0xC1, 0x82, 0xBC, 0x04, 0xA8, 0x24, 0x0C,
  0xB1, 0xC1, 0x02, 0x04, 0x20, 0x07, 0x20, 0x40, 0x21, 0xC5, 0x00, 0xD5, 0xC7, 0x58, 0x0D, 0x6F,
  0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xD0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_on_device_training() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 1, 19, 22), Box(0, 0, 23, 23),
      ic_round_24_action_on_device_training_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_online_prediction 24x24, 4-bit Alpha,  RLE, 125 bytes.
static const unsigned char ic_round_24_action_online_prediction_data[] PROGMEM = {
  0x20, 0x70, 0x57, 0x50, 0x50, 0x73, 0x81, 0x4F, 0x77, 0x58, 0x17, 0xF4, 0x28, 0x3D, 0xC0, 0x45,
  0x71, 0x8C, 0x05, 0x40, 0xCD, 0x05, 0xF4, 0x1E, 0xA0, 0x19, 0xDD, 0x91, 0x0A, 0xE1, 0x4F, 0x59,
  0xD0, 0x7F, 0x20, 0xCC, 0x89, 0x5C, 0x02, 0xF7, 0x0D, 0x9D, 0xA0, 0xCB, 0x04, 0xE8, 0x94, 0x40,
  0xBC, 0x0A, 0xDE, 0x80, 0xE8, 0x07, 0xE8, 0x94, 0x60, 0x8E, 0x08, 0xEE, 0x80, 0xE8, 0x04, 0xE8,
  0x92, 0x30, 0x8E, 0x08, 0xED, 0xA0, 0xCB, 0x20, 0xBC, 0x0B, 0x28, 0x94, 0xBC, 0x0A, 0xD9, 0xD0,
  0x7F, 0x20, 0x1E, 0xA8, 0x95, 0xE1, 0x02, 0xF8, 0x0D, 0x95, 0xF4, 0x1E, 0xA2, 0x05, 0xA0, 0x52,
  0x89, 0x2A, 0xE1, 0x4F, 0x50, 0xDC, 0x04, 0x53, 0x00, 0x73, 0x83, 0x54, 0x0C, 0xD2, 0x81, 0x4F,
  0x75, 0x00, 0x75, 0x81, 0x7F, 0x43, 0x07, 0x05, 0x50, 0x0B, 0x50, 0x50, 0x72,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_online_prediction() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 5, 21, 18), Box(0, 0, 23, 23),
      ic_round_24_action_online_prediction_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_opacity 24x24, 4-bit Alpha,  RLE, 85 bytes.
static const unsigned char ic_round_24_action_opacity_data[] PROGMEM = {
  0x70, 0x05, 0x76, 0x08, 0xA0, 0x87, 0x40, 0x8C, 0x08, 0x72, 0x08, 0xA0, 0x04, 0xA0, 0x87, 0x08,
  0xA0, 0x42, 0x04, 0xA0, 0x85, 0x08, 0xA0, 0x44, 0x04, 0xA0, 0x83, 0x82, 0x6F, 0xE4, 0x68, 0x74,
  0xEF, 0x60, 0x1E, 0xF5, 0x71, 0x85, 0x5F, 0xE1, 0x7F, 0xA7, 0x38, 0x4A, 0xF7, 0xCF, 0x47, 0x38,
  0x44, 0xFC, 0xEF, 0x17, 0x38, 0x41, 0xFE, 0xEF, 0x17, 0x38, 0x21, 0xFE, 0xDF, 0xF0, 0xD0, 0x9F,
  0xF0, 0x90, 0x3F, 0xF8, 0x13, 0x09, 0xFD, 0x09, 0x30, 0xBF, 0xB0, 0xB5, 0x09, 0xF9, 0x09, 0x78,
  0x62, 0x8C, 0xEE, 0xC8, 0x24,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_opacity() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 20), Box(0, 0, 23, 23),
      ic_round_24_action_opacity_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_open_in_browser 24x24, 4-bit Alpha,  RLE, 52 bytes.
static const unsigned char ic_round_24_action_open_in_browser_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xC2, 0xF7, 0x7C, 0x77, 0xC6, 0x00, 0x76,
  0xC5, 0x07, 0xA0, 0x75, 0xC4, 0x07, 0xC0, 0x74, 0xC3, 0x02, 0xE0, 0x23, 0xC6, 0xA6, 0xC6, 0xA6,
  0xC6, 0xA6, 0xC6, 0xA6, 0xA0, 0xDC, 0x0B, 0x2A, 0x20, 0xBC, 0x81, 0xD4, 0xDB, 0x0B, 0x20, 0x0B,
  0x20, 0xBB, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_open_in_browser() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 4, 20, 19), Box(0, 0, 23, 23),
      ic_round_24_action_open_in_browser_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_open_in_full 24x24, 4-bit Alpha,  RLE, 76 bytes.
static const unsigned char ic_round_24_action_open_in_full_data[] PROGMEM = {
  0x74, 0x05, 0xD0, 0xB7, 0x40, 0x5E, 0x75, 0x07, 0xD7, 0x50, 0x10, 0xEC, 0x74, 0x82, 0x1C, 0xFE,
  0xB7, 0x38, 0x41, 0xCF, 0xC1, 0x7A, 0x72, 0x83, 0x1C, 0xFC, 0x12, 0x00, 0x57, 0x18, 0x31, 0xCF,
  0xC1, 0x75, 0x83, 0x1C, 0xFC, 0x17, 0x58, 0x31, 0xCF, 0xC1, 0x75, 0x83, 0x1C, 0xFC, 0x17, 0x10,
  0x05, 0x28, 0x31, 0xCF, 0xC1, 0x72, 0xA8, 0x47, 0x1C, 0xFC, 0x17, 0x3B, 0x82, 0xEF, 0xC1, 0x74,
  0xC0, 0xE0, 0x17, 0x5D, 0x07, 0x75, 0xE0, 0x57, 0x40, 0xBD, 0x05, 0x74,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_open_in_full() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_open_in_full_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_open_in_new_off 24x24, 4-bit Alpha,  RLE, 123 bytes.
static const unsigned char ic_round_24_action_open_in_new_off_data[] PROGMEM = {
  0x10, 0x90, 0x62, 0x0A, 0xC0, 0xB2, 0x02, 0xD0, 0xE0, 0x1A, 0x07, 0x20, 0xAB, 0x0B, 0x30, 0x7D,
  0x10, 0x5A, 0x07, 0x73, 0x08, 0xC2, 0xB0, 0x77, 0x10, 0x10, 0xCC, 0x2C, 0x07, 0x68, 0x31, 0xCF,
  0xC8, 0xA2, 0xA0, 0x5A, 0x07, 0x48, 0x51, 0xCF, 0xC1, 0x07, 0x92, 0xA1, 0x05, 0xA0, 0x72, 0x83,
  0x1C, 0xFC, 0x13, 0x02, 0x2A, 0x20, 0x5A, 0x07, 0x28, 0x1A, 0xC1, 0x7A, 0x30, 0x5A, 0x07, 0x20,
  0x17, 0x1A, 0x40, 0x6A, 0x07, 0x60, 0x0B, 0x2A, 0x40, 0xCB, 0x07, 0x5A, 0x2A, 0x38, 0x22, 0xFC,
  0x6A, 0x07, 0x4A, 0x2A, 0x40, 0x22, 0x05, 0xA0, 0x73, 0xA2, 0xA7, 0x10, 0x5A, 0x07, 0x20, 0xA9,
  0x2A, 0x72, 0x05, 0xA0, 0x72, 0x0A, 0x2A, 0x73, 0x05, 0xA0, 0x74, 0x0D, 0xFF, 0x90, 0x73, 0x04,
  0x0D, 0xFF, 0x90, 0x67, 0x73, 0x81, 0x5F, 0x97, 0x74, 0x01, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_open_in_new_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 20, 22), Box(0, 0, 23, 23),
      ic_round_24_action_open_in_new_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_open_in_new 24x24, 4-bit Alpha,  RLE, 83 bytes.
static const unsigned char ic_round_24_action_open_in_new_data[] PROGMEM = {
  0x04, 0x0D, 0xE0, 0xB2, 0x0B, 0xD0, 0xB0, 0xDF, 0x0B, 0x20, 0xBF, 0x90, 0x37, 0x30, 0x10, 0xCD,
  0x73, 0x82, 0x1C, 0xFC, 0xC7, 0x28, 0x31, 0xCF, 0xC1, 0xC7, 0x18, 0x31, 0xCF, 0xC1, 0x1C, 0x78,
  0x31, 0xCF, 0xC1, 0x20, 0x0B, 0xA6, 0x83, 0x1C, 0xFC, 0x15, 0xA5, 0x83, 0x1C, 0xFC, 0x16, 0xA4,
  0x83, 0x1C, 0xFC, 0x15, 0x00, 0xBA, 0x38, 0x31, 0xCF, 0xC1, 0x6C, 0x38, 0x2A, 0xFC, 0x17, 0xC3,
  0x81, 0x6A, 0x17, 0x1C, 0x77, 0xC7, 0x7C, 0x03, 0x75, 0x03, 0xA0, 0xDF, 0xFA, 0x81, 0xD4, 0xDF,
  0xF0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_open_in_new() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_open_in_new_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_open_with 24x24, 4-bit Alpha,  RLE, 93 bytes.
static const unsigned char ic_round_24_action_open_with_data[] PROGMEM = {
  0x73, 0x00, 0x77, 0x75, 0x07, 0xA0, 0x77, 0x73, 0x07, 0xC0, 0x77, 0x71, 0x07, 0xE0, 0x77, 0x60,
  0x2F, 0x90, 0x27, 0x71, 0xC7, 0x60, 0x24, 0xC4, 0x02, 0x70, 0x79, 0x40, 0xEA, 0x0E, 0x49, 0x07,
  0x50, 0x7A, 0x75, 0xA0, 0x73, 0x07, 0xD0, 0xE6, 0x0E, 0xD8, 0x17, 0x07, 0xF6, 0xF0, 0x07, 0xF6,
  0xF8, 0x17, 0x07, 0xD0, 0xE6, 0x0E, 0xD0, 0x73, 0x07, 0xA7, 0x5A, 0x07, 0x50, 0x79, 0x40, 0xEA,
  0x0E, 0x49, 0x07, 0x70, 0x24, 0xC4, 0x02, 0x76, 0xC7, 0x71, 0x02, 0xF9, 0x02, 0x76, 0x07, 0xE0,
  0x77, 0x71, 0x07, 0xC0, 0x77, 0x73, 0x07, 0xA0, 0x77, 0x75, 0x00, 0x77, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_open_with() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_open_with_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_outbond 24x24, 4-bit Alpha,  RLE, 107 bytes.
static const unsigned char ic_round_24_action_outbond_data[] PROGMEM = {
  0x68, 0x64, 0x9C, 0xDD, 0xB8, 0x37, 0x30, 0x40, 0xDF, 0x90, 0xC0, 0x37, 0x07, 0xFD, 0x06, 0x50,
  0x8F, 0xF0, 0x63, 0x05, 0xFF, 0xA0, 0x32, 0x0D, 0xFF, 0xA8, 0x1C, 0x05, 0xF9, 0x04, 0x30, 0x4D,
  0x03, 0x0A, 0xF9, 0x0A, 0x30, 0x1D, 0x08, 0x0D, 0xF9, 0x0E, 0x01, 0x20, 0x1D, 0x0B, 0xF9, 0x84,
  0xE2, 0x01, 0x01, 0xD0, 0xDF, 0x85, 0xE2, 0x02, 0xEA, 0x6D, 0x0D, 0x0E, 0xD8, 0x3E, 0x20, 0x2E,
  0xF9, 0x0C, 0x0B, 0xD8, 0x23, 0x02, 0xEF, 0xA0, 0x90, 0x6D, 0x81, 0x33, 0xEF, 0xB8, 0x14, 0x1E,
  0xFF, 0xA0, 0xD2, 0x06, 0xFF, 0xA0, 0x43, 0x09, 0xFF, 0x07, 0x50, 0x9F, 0xD0, 0x87, 0x06, 0x0E,
  0xF9, 0x0D, 0x05, 0x72, 0x82, 0x16, 0xBE, 0xA8, 0x1D, 0xA5, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_outbond() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_outbond_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_outbound 24x24, 4-bit Alpha,  RLE, 104 bytes.
static const unsigned char ic_round_24_action_outbound_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFF, 0xA0, 0x42, 0x0D, 0xFF, 0xA8, 0x1D, 0x05, 0xF9, 0x02, 0x30, 0x1D,
  0x05, 0x09, 0xF9, 0x0C, 0x4D, 0x09, 0x0D, 0xF9, 0x0E, 0x02, 0x3D, 0x0D, 0x0E, 0xF8, 0x2E, 0x20,
  0x22, 0xD0, 0x0E, 0xE8, 0x5E, 0x20, 0x2E, 0xC3, 0xD0, 0xE0, 0xDD, 0x83, 0xE2, 0x02, 0xEF, 0x90,
  0xD0, 0x9D, 0x82, 0x30, 0x2E, 0xFA, 0x09, 0x05, 0xD8, 0x12, 0x3E, 0xFB, 0x81, 0x50, 0xDF, 0xFA,
  0x0D, 0x20, 0x4F, 0xFA, 0x04, 0x30, 0x8F, 0xF0, 0x85, 0x08, 0xFD, 0x08, 0x70, 0x40, 0xDF, 0x90,
  0xD0, 0x47, 0x38, 0x65, 0x9D, 0xEE, 0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_outbound() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_outbound_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_outbox 24x24, 4-bit Alpha,  RLE, 52 bytes.
static const unsigned char ic_round_24_action_outbox_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0xA7, 0x7C, 0x77, 0xC6, 0x00, 0x76, 0xC5, 0x07,
  0xA0, 0x75, 0xC4, 0x07, 0xC0, 0x74, 0xC3, 0x02, 0xE0, 0x23, 0xC6, 0xA6, 0xC6, 0xA6, 0xC6, 0x00,
  0xB6, 0xF0, 0xD0, 0x44, 0x04, 0x0D, 0xFD, 0x06, 0x20, 0x68, 0x0F, 0x1F, 0x0D, 0xFF, 0xA8, 0x1D,
  0x4D, 0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_outbox() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_outbox_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_outlet 24x24, 4-bit Alpha,  RLE, 97 bytes.
static const unsigned char ic_round_24_action_outlet_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFF, 0xA0, 0x42, 0x0D, 0xC0, 0x03, 0xC0, 0x03, 0xC8, 0x1D, 0x05, 0xD2,
  0xC2, 0xD0, 0x50, 0x9D, 0x2C, 0x2D, 0x09, 0x0D, 0xD2, 0xC2, 0xD0, 0xD0, 0xED, 0x00, 0x3C, 0x00,
  0x3D, 0x00, 0xEF, 0xFC, 0x0E, 0x0D, 0xFF, 0xC0, 0xD0, 0x9F, 0x82, 0xB1, 0x1B, 0xF0, 0x90, 0x5F,
  0x02, 0x20, 0x1F, 0x81, 0x50, 0xDE, 0x4E, 0x0D, 0x20, 0x4E, 0x03, 0x20, 0x3E, 0x04, 0x30, 0x8F,
  0xF0, 0x85, 0x08, 0xFD, 0x08, 0x70, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x38, 0x65, 0x9D, 0xEE, 0xD9,
  0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_outlet() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_outlet_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_output 24x24, 4-bit Alpha,  RLE, 72 bytes.
static const unsigned char ic_round_24_action_output_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x82, 0xD4, 0x0D, 0xFF, 0xA0, 0xD1, 0xA7, 0x7A, 0x1A, 0x77, 0x00, 0xB1, 0xA7,
  0x40, 0x05, 0x4A, 0x74, 0x81, 0xDF, 0x73, 0xA7, 0x40, 0x5A, 0x07, 0x2A, 0x75, 0x05, 0xA0, 0x71,
  0xA4, 0x0B, 0xFC, 0x05, 0xA4, 0x0B, 0xFC, 0x05, 0xA7, 0x50, 0x5A, 0x07, 0x1A, 0x74, 0x05, 0xA0,
  0x72, 0xA7, 0x48, 0x1D, 0xF7, 0x3A, 0x74, 0x00, 0x54, 0xA7, 0x70, 0x0B, 0x1A, 0x77, 0xA1, 0x0D,
  0xFF, 0xA8, 0x2D, 0x04, 0xDF, 0xF0, 0xD0, 0x41,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_output() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_output_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_pageview 24x24, 4-bit Alpha,  RLE, 79 bytes.
static const unsigned char ic_round_24_action_pageview_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDF, 0xFF, 0xD8, 0x4E, 0x72, 0x02, 0x7F, 0xE0,
  0xE0, 0x35, 0x03, 0xFD, 0x87, 0x70, 0x1B, 0xEB, 0x10, 0x7F, 0xC8, 0x12, 0x0B, 0xB8, 0x1B, 0x02,
  0xFC, 0x20, 0xEB, 0x81, 0xE0, 0x1F, 0xC8, 0x12, 0x0B, 0xB8, 0x1B, 0x02, 0xFC, 0x87, 0x80, 0x1B,
  0xEB, 0x10, 0x8F, 0xD0, 0x36, 0x02, 0x0E, 0xFD, 0x87, 0x82, 0x02, 0x72, 0x02, 0xEF, 0xFA, 0x82,
  0xE2, 0x05, 0xFF, 0xB8, 0x1E, 0x5A, 0xC0, 0xDF, 0xFC, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_pageview() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_pageview_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_paid 24x24, 4-bit Alpha,  RLE, 132 bytes.
static const unsigned char ic_round_24_action_paid_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8E, 0x00, 0x5E, 0x08, 0x30, 0x4D, 0x0E, 0x07, 0x20, 0x60, 0xED, 0x04, 0x20, 0xDC, 0x86, 0xE2,
  0x01, 0x10, 0x2E, 0xC8, 0x1D, 0x05, 0xD8, 0x19, 0x06, 0xA8, 0x19, 0x2E, 0xD0, 0x50, 0x9D, 0x81,
  0x80, 0x9F, 0xB0, 0x90, 0xDD, 0x83, 0xC0, 0x18, 0xEF, 0x90, 0xD0, 0xEE, 0x0A, 0x01, 0x20, 0x50,
  0xDE, 0x00, 0xEF, 0x84, 0xE9, 0x30, 0x1C, 0xD0, 0xE0, 0xDF, 0xB8, 0x19, 0x04, 0xD0, 0xD0, 0x9D,
  0x0B, 0x07, 0xC0, 0x10, 0x2D, 0x09, 0x05, 0xD8, 0x17, 0x06, 0xA8, 0x1A, 0x04, 0xD8, 0x15, 0x0D,
  0xC0, 0xE0, 0x22, 0x01, 0x20, 0xBC, 0x0D, 0x20, 0x4D, 0x0E, 0x08, 0x20, 0x60, 0xDD, 0x04, 0x30,
  0x8E, 0x00, 0x5E, 0x08, 0x50, 0x8F, 0xD0, 0x87, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59,
  0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_paid() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_paid_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_pan_tool_alt 24x24, 4-bit Alpha,  RLE, 55 bytes.
static const unsigned char ic_round_24_action_pan_tool_alt_data[] PROGMEM = {
  0x58, 0x18, 0xE8, 0x75, 0xB7, 0x5B, 0x75, 0xB7, 0x5B, 0x75, 0xB7, 0x5B, 0x75, 0xB0, 0x70, 0x57,
  0x3D, 0x0E, 0x06, 0x71, 0xF0, 0xE0, 0x66, 0xFA, 0x83, 0xA3, 0x74, 0x11, 0xFA, 0x0E, 0x0B, 0xB0,
  0xDF, 0xA8, 0x1D, 0x3E, 0xFD, 0x82, 0xB0, 0x3E, 0xFC, 0x09, 0x20, 0x4F, 0xC0, 0x73, 0x05, 0xFB,
  0x04, 0x40, 0x50, 0xDE, 0x0E, 0x09, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_pan_tool_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 19, 20), Box(0, 0, 23, 23),
      ic_round_24_action_pan_tool_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_pan_tool 24x24, 4-bit Alpha,  RLE, 99 bytes.
static const unsigned char ic_round_24_action_pan_tool_data[] PROGMEM = {
  0x74, 0x81, 0x8E, 0x87, 0x75, 0xB1, 0x81, 0x8E, 0x87, 0x71, 0xB1, 0xB7, 0x48, 0x18, 0xE8, 0x1B,
  0x1B, 0x74, 0xB1, 0xB1, 0xB1, 0x81, 0x8E, 0x87, 0xB1, 0xB1, 0xB1, 0xB7, 0xB1, 0xB1, 0xB1, 0xB7,
  0xB1, 0xB1, 0xB1, 0xB7, 0xB1, 0xB1, 0xB1, 0xB7, 0xB1, 0xB1, 0xB1, 0xB7, 0xB0, 0x2B, 0x02, 0xB0,
  0x2B, 0x7F, 0xF9, 0x7F, 0xF9, 0x18, 0x16, 0x81, 0x3F, 0xF9, 0x04, 0xB0, 0x72, 0xFF, 0x90, 0x2C,
  0x0D, 0x05, 0xFF, 0x91, 0x05, 0xFF, 0xE2, 0x05, 0xFF, 0xD3, 0x05, 0xFF, 0xC4, 0x06, 0xFF, 0xB5,
  0x06, 0xFF, 0x90, 0xD6, 0x06, 0xFF, 0x0A, 0x70, 0x6F, 0xD0, 0xE0, 0x17, 0x18, 0x14, 0xBE, 0xF8,
  0x1D, 0xA1, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_pan_tool() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 0, 22, 23), Box(0, 0, 23, 23),
      ic_round_24_action_pan_tool_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_payment 24x24, 4-bit Alpha,  RLE, 39 bytes.
static const unsigned char ic_round_24_action_payment_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDA, 0x03, 0x77, 0x03, 0xC7, 0x72, 0x80, 0x9A,
  0x0F, 0x77, 0x2C, 0x77, 0x2C, 0x77, 0x2C, 0x77, 0x2C, 0x77, 0x2C, 0x03, 0x77, 0x03, 0xA0, 0xDF,
  0xFC, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_payment() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_payment_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_pending_actions 24x24, 4-bit Alpha,  RLE, 105 bytes.
static const unsigned char ic_round_24_action_pending_actions_data[] PROGMEM = {
  0x68, 0x28, 0xEE, 0x87, 0x60, 0x8C, 0x08, 0x70, 0x40, 0xDD, 0x00, 0x3D, 0x0D, 0x04, 0x20, 0xDE,
  0x00, 0x3E, 0x0D, 0x2A, 0x2F, 0x92, 0xA2, 0xA2, 0x0D, 0xE0, 0xD2, 0xA2, 0xA2, 0x04, 0x0D, 0xC0,
  0xD0, 0x42, 0xA2, 0xA7, 0x5A, 0x2A, 0x75, 0xA2, 0xA7, 0x50, 0x20, 0x72, 0xA7, 0x72, 0xA7, 0x18,
  0x44, 0xBE, 0xEB, 0x42, 0xA7, 0x08, 0xE0, 0x81, 0xA6, 0x04, 0xB0, 0x80, 0x9B, 0x04, 0xA6, 0x0B,
  0xB0, 0x07, 0xB0, 0xBA, 0x60, 0xEB, 0x00, 0x7B, 0x0E, 0xA6, 0x0E, 0xB8, 0x1C, 0x1B, 0xA0, 0xEA,
  0x60, 0xBC, 0x83, 0xB1, 0xEF, 0xBA, 0x60, 0x4D, 0x0E, 0xA0, 0x40, 0xDD, 0x82, 0xE1, 0x08, 0xE8,
  0x28, 0x04, 0xDD, 0x0A, 0x28, 0x44, 0xBE, 0xEB, 0x42,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_pending_actions() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 1, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_pending_actions_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_pending 24x24, 4-bit Alpha,  RLE, 108 bytes.
static const unsigned char ic_round_24_action_pending_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFF, 0xA0, 0x42, 0x0D, 0xFF, 0xA8, 0x1D, 0x05, 0xFF, 0xC0, 0x50, 0x9F,
  0xFC, 0x09, 0x0D, 0xB0, 0x09, 0xB0, 0x09, 0xB0, 0x09, 0xB0, 0xD0, 0xEA, 0x09, 0x28, 0x19, 0xF9,
  0x28, 0x19, 0xF9, 0x20, 0x9A, 0x00, 0xEA, 0x09, 0x28, 0x19, 0xF9, 0x28, 0x19, 0xF9, 0x20, 0x9A,
  0x0E, 0x0D, 0xB0, 0x09, 0xB0, 0x09, 0xB0, 0x09, 0xB0, 0xD0, 0x9F, 0xFC, 0x09, 0x05, 0xFF, 0xC8,
  0x15, 0x0D, 0xFF, 0xA0, 0xD2, 0x04, 0xFF, 0xA0, 0x43, 0x08, 0xFF, 0x08, 0x50, 0x8F, 0xD0, 0x87,
  0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_pending() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_pending_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_percent 24x24, 4-bit Alpha,  RLE, 110 bytes.
static const unsigned char ic_round_24_action_percent_data[] PROGMEM = {
  0x18, 0x34, 0xCE, 0xC4, 0x78, 0x21, 0x71, 0x4D, 0x04, 0x58, 0x91, 0x1C, 0xF7, 0xCF, 0x70, 0x7F,
  0xC4, 0x84, 0x1C, 0xFC, 0x1E, 0x93, 0x90, 0xE3, 0x89, 0x31, 0xCF, 0xC1, 0x0C, 0xF7, 0x07, 0xFC,
  0x28, 0x31, 0xCF, 0xC1, 0x20, 0x4D, 0x85, 0x40, 0x1C, 0xFC, 0x14, 0x89, 0x14, 0xCE, 0xC4, 0x01,
  0xCF, 0xC1, 0x73, 0x83, 0x1C, 0xFC, 0x17, 0x38, 0x31, 0xCF, 0xC1, 0x73, 0x89, 0x11, 0xCF, 0xC1,
  0x04, 0xCE, 0xC4, 0x48, 0x51, 0xCF, 0xC1, 0x04, 0xD0, 0x42, 0x83, 0x1C, 0xFC, 0x12, 0x89, 0x3C,
  0xF7, 0x07, 0xFC, 0x01, 0xCF, 0xC1, 0x30, 0xE9, 0x39, 0x84, 0xE1, 0xCF, 0xC1, 0x48, 0x91, 0xCF,
  0x70, 0x7F, 0xC7, 0xFC, 0x15, 0x04, 0xD8, 0x24, 0x17, 0x17, 0x83, 0x4C, 0xEC, 0x41,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_percent() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 4, 19, 19), Box(0, 0, 23, 23),
      ic_round_24_action_percent_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_perm_camera_mic 24x24, 4-bit Alpha,  RLE, 87 bytes.
static const unsigned char ic_round_24_action_perm_camera_mic_data[] PROGMEM = {
  0x60, 0x60, 0xEC, 0x0E, 0x06, 0x74, 0x05, 0xF9, 0x05, 0x50, 0x40, 0xDF, 0xFA, 0x81, 0xD4, 0xDF,
  0xFC, 0x0D, 0xF9, 0x82, 0xB1, 0x1B, 0xFF, 0xA0, 0x12, 0x01, 0xFF, 0xA4, 0xFF, 0xA4, 0xFF, 0xA4,
  0xFF, 0xA4, 0xFD, 0x05, 0x03, 0xA0, 0x12, 0x01, 0xA0, 0x20, 0x5F, 0x98, 0x92, 0x30, 0xAF, 0xB1,
  0x1B, 0xF9, 0x03, 0xF9, 0x82, 0x90, 0x2E, 0xC8, 0x2E, 0x20, 0x9F, 0xA8, 0x90, 0x30, 0x2A, 0xEE,
  0xA2, 0x03, 0xFB, 0x0D, 0x03, 0x60, 0x30, 0xEF, 0xD0, 0x90, 0x32, 0x03, 0x09, 0xF0, 0xDF, 0x92,
  0xF9, 0x81, 0xD4, 0xDF, 0x2F, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_perm_camera_mic() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_perm_camera_mic_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_perm_contact_calendar 24x24, 4-bit Alpha,  RLE, 69 bytes.
static const unsigned char ic_round_24_action_perm_contact_calendar_data[] PROGMEM = {
  0x30, 0x0B, 0x71, 0x00, 0xB6, 0xA7, 0x1A, 0x30, 0x40, 0xDF, 0xF8, 0x1D, 0x4D, 0xFF, 0xA0, 0xDF,
  0xFF, 0xC8, 0x27, 0x11, 0x7F, 0xE0, 0x74, 0x07, 0xFD, 0x01, 0x40, 0x1F, 0xD0, 0x14, 0x01, 0xFD,
  0x07, 0x40, 0x7F, 0xE8, 0x27, 0x11, 0x7F, 0xFF, 0xFD, 0x00, 0xEF, 0xE0, 0x90, 0x53, 0x81, 0x15,
  0x9F, 0x90, 0xC0, 0x17, 0x10, 0x10, 0xCE, 0x02, 0x73, 0x02, 0xE7, 0x5F, 0xFF, 0x0D, 0xFF, 0xA8,
  0x1D, 0x4D, 0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_perm_contact_calendar() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 1, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_perm_contact_calendar_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_perm_data_setting 24x24, 4-bit Alpha,  RLE, 115 bytes.
static const unsigned char ic_round_24_action_perm_data_setting_data[] PROGMEM = {
  0x77, 0x30, 0x05, 0x77, 0x60, 0x7A, 0x77, 0x50, 0x7B, 0x77, 0x40, 0x7C, 0x77, 0x30, 0x7D, 0x77,
  0x20, 0x7E, 0x77, 0x10, 0x7F, 0x77, 0x07, 0xF9, 0x76, 0x07, 0xFA, 0x75, 0x07, 0xFB, 0x74, 0x07,
  0xF8, 0x2E, 0xA8, 0x77, 0x30, 0x7E, 0x0E, 0x06, 0x76, 0x07, 0xE0, 0xC0, 0x17, 0x60, 0x7E, 0x0E,
  0x01, 0x30, 0x4A, 0x03, 0x60, 0x7F, 0x06, 0x28, 0x15, 0x19, 0xA8, 0x18, 0x15, 0x30, 0x7F, 0x0E,
  0x20, 0x5F, 0x98, 0x15, 0x07, 0xF9, 0x0A, 0x20, 0xBB, 0x00, 0x9B, 0x0A, 0x05, 0xFA, 0x08, 0x38,
  0x1D, 0xF9, 0x28, 0x3A, 0xFC, 0x05, 0xFA, 0x08, 0x38, 0x1D, 0xF9, 0x28, 0x1A, 0xFC, 0x77, 0x0B,
  0xB0, 0x09, 0xB0, 0xA7, 0x60, 0x5F, 0x90, 0x57, 0x78, 0x15, 0x19, 0xA8, 0x19, 0x15, 0x77, 0x30,
  0x4A, 0x04, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_perm_data_setting() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 23, 23), Box(0, 0, 23, 23),
      ic_round_24_action_perm_data_setting_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_perm_device_information 24x24, 4-bit Alpha,  RLE, 47 bytes.
static const unsigned char ic_round_24_action_perm_device_information_data[] PROGMEM = {
  0x04, 0x0D, 0xFB, 0x81, 0xD4, 0xDF, 0xD0, 0xDF, 0xFF, 0xFA, 0x73, 0xC7, 0x3C, 0x4A, 0x4C, 0x4A,
  0x4C, 0x73, 0xC7, 0x3C, 0x40, 0x0B, 0x4C, 0x4A, 0x4C, 0x4A, 0x4C, 0x4A, 0x4C, 0x4A, 0x4C, 0x40,
  0x0B, 0x4C, 0x73, 0xC7, 0x3F, 0xFF, 0xFA, 0x0D, 0xFD, 0x81, 0xD4, 0xDF, 0xB0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_perm_device_information() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 1, 18, 22), Box(0, 0, 23, 23),
      ic_round_24_action_perm_device_information_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_perm_identity 24x24, 4-bit Alpha,  RLE, 81 bytes.
static const unsigned char ic_round_24_action_perm_identity_data[] PROGMEM = {
  0x58, 0x41, 0xAD, 0xDA, 0x17, 0x20, 0x10, 0xEC, 0x0E, 0x01, 0x71, 0x86, 0xAF, 0xB1, 0x1B, 0xFA,
  0x71, 0x81, 0xDF, 0x12, 0x81, 0x1F, 0xD7, 0x18, 0x1D, 0xF1, 0x28, 0x11, 0xFD, 0x71, 0x86, 0xAF,
  0xB1, 0x1B, 0xFA, 0x71, 0x01, 0x0E, 0xC0, 0xE0, 0x17, 0x28, 0x41, 0xAD, 0xDA, 0x17, 0x77, 0x38,
  0x90, 0x26, 0xAD, 0xEF, 0xDA, 0x62, 0x40, 0x30, 0xBF, 0xB8, 0x2B, 0x30, 0x4A, 0x82, 0xE9, 0x52,
  0x28, 0x22, 0x59, 0xEA, 0x82, 0x4D, 0xF8, 0x73, 0x81, 0x8F, 0xDA, 0x75, 0xFF, 0xC0, 0xBF, 0xF0,
  0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_perm_identity() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 4, 19, 19), Box(0, 0, 23, 23),
      ic_round_24_action_perm_identity_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_perm_media 24x24, 4-bit Alpha,  RLE, 76 bytes.
static const unsigned char ic_round_24_action_perm_media_data[] PROGMEM = {
  0x40, 0x40, 0xDC, 0x0E, 0x06, 0x77, 0x0D, 0xF0, 0x77, 0x6F, 0xFA, 0x0D, 0x04, 0x4F, 0xFB, 0x81,
  0xDB, 0xB2, 0xFF, 0xE2, 0xFF, 0xE2, 0xFB, 0x0E, 0xFA, 0x2F, 0xA8, 0x1C, 0x09, 0xF9, 0x2D, 0x83,
  0xC5, 0xEE, 0x22, 0x0C, 0xF2, 0xC8, 0x3E, 0x20, 0x55, 0x30, 0x20, 0xEE, 0x2C, 0x09, 0x71, 0x0A,
  0xE2, 0xFF, 0xE2, 0xFF, 0xE2, 0x0D, 0xFF, 0xA0, 0xDA, 0x20, 0x40, 0xDF, 0xF0, 0xD0, 0x4A, 0x77,
  0x6A, 0x77, 0x60, 0xDF, 0xFB, 0x0B, 0x30, 0x40, 0xDF, 0xFA, 0x0B, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_perm_media() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_perm_media_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_perm_phone_msg 24x24, 4-bit Alpha,  RLE, 89 bytes.
static const unsigned char ic_round_24_action_perm_phone_msg_data[] PROGMEM = {
  0x04, 0x0D, 0xA0, 0xC0, 0x23, 0x0B, 0xF0, 0xB0, 0xDC, 0x0A, 0x3F, 0xA0, 0xDC, 0x0C, 0x3F, 0xA0,
  0xBC, 0x0E, 0x3F, 0xA0, 0x9D, 0x3F, 0xA0, 0x5C, 0x0B, 0x3F, 0xA1, 0xB0, 0xC0, 0x13, 0xF9, 0x84,
  0xB0, 0xAF, 0xD1, 0x4A, 0x07, 0x78, 0x23, 0xFE, 0x14, 0x90, 0x77, 0x28, 0x1A, 0xFA, 0x40, 0x77,
  0x38, 0x21, 0xEF, 0x67, 0x71, 0x04, 0xA0, 0x57, 0x71, 0x07, 0xA0, 0x63, 0x85, 0x1B, 0xFE, 0xCA,
  0x25, 0x07, 0xA8, 0x2A, 0x11, 0xCD, 0x0C, 0x68, 0x34, 0xEF, 0xED, 0xF7, 0x01, 0x0A, 0xFA, 0x72,
  0x03, 0x0A, 0xE0, 0xD7, 0x58, 0x45, 0x9B, 0xED, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_perm_phone_msg() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_perm_phone_msg_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_perm_scan_wifi 24x24, 4-bit Alpha,  RLE, 96 bytes.
static const unsigned char ic_round_24_action_perm_scan_wifi_data[] PROGMEM = {
  0x68, 0x32, 0x6A, 0xCD, 0xA8, 0x3D, 0xCA, 0x62, 0x73, 0x06, 0x0C, 0xFD, 0x0C, 0x05, 0x60, 0x60,
  0xEF, 0xFA, 0x0E, 0x05, 0x20, 0x10, 0xCF, 0xA2, 0xFA, 0x81, 0xB1, 0x7F, 0xB2, 0xFB, 0x81, 0x71,
  0xDF, 0xFE, 0x83, 0xD1, 0x02, 0xEF, 0xFC, 0x0E, 0x03, 0x30, 0x5F, 0x90, 0x03, 0xF9, 0x05, 0x50,
  0x8F, 0x2F, 0x08, 0x70, 0xAE, 0x2E, 0x0B, 0x72, 0x0D, 0xD2, 0xD0, 0xD0, 0x17, 0x20, 0x20, 0xEC,
  0x2C, 0x0E, 0x02, 0x74, 0x04, 0xC0, 0x03, 0xC0, 0x47, 0x60, 0x7F, 0x90, 0x77, 0x71, 0x0A, 0xE0,
  0xA7, 0x73, 0x0C, 0xC0, 0xC7, 0x74, 0x01, 0x0E, 0xA0, 0xE0, 0x17, 0x75, 0x82, 0x2A, 0xA2, 0x73,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_perm_scan_wifi() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 3, 23, 20), Box(0, 0, 23, 23),
      ic_round_24_action_perm_scan_wifi_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_pets 24x24, 4-bit Alpha,  RLE, 114 bytes.
static const unsigned char ic_round_24_action_pets_data[] PROGMEM = {
  0x58, 0x26, 0xDD, 0x62, 0x82, 0x6D, 0xD6, 0x72, 0x03, 0xC0, 0x03, 0xC0, 0x37, 0x10, 0x6C, 0x00,
  0x6C, 0x06, 0x71, 0x03, 0xC0, 0x03, 0xC0, 0x34, 0x87, 0x1B, 0xEB, 0x16, 0xDD, 0x62, 0x89, 0x06,
  0xDD, 0x61, 0xBE, 0xB1, 0xBB, 0x0B, 0x73, 0x0B, 0xB0, 0xB0, 0xEB, 0x0E, 0x73, 0x0E, 0xB0, 0xE0,
  0xBB, 0x0B, 0x38, 0x22, 0x77, 0x23, 0x0B, 0xB8, 0x4B, 0x1B, 0xEB, 0x12, 0x06, 0xC0, 0x62, 0x83,
  0x1B, 0xEB, 0x16, 0x05, 0xE0, 0x57, 0x40, 0x30, 0xEE, 0x0E, 0x03, 0x72, 0x01, 0x0E, 0xF9, 0x0E,
  0x01, 0x70, 0x10, 0xDF, 0xB0, 0xD0, 0x16, 0x0C, 0xFD, 0x0C, 0x50, 0x7F, 0xF0, 0x74, 0x0D, 0xFF,
  0x0D, 0x40, 0xEF, 0xF0, 0xE4, 0x09, 0xFF, 0x08, 0x58, 0x94, 0x9F, 0xEC, 0xA9, 0x88, 0x9A, 0xCE,
  0xE9, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_pets() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_pets_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_php 24x24, 4-bit Alpha,  RLE, 56 bytes.
static const unsigned char ic_round_24_action_php_data[] PROGMEM = {
  0x0B, 0xB8, 0x28, 0x05, 0xC2, 0x82, 0xC5, 0x04, 0xB8, 0x7D, 0x2F, 0xB7, 0xBF, 0x07, 0x92, 0x98,
  0x95, 0x70, 0x7F, 0x77, 0xF7, 0xFB, 0x7B, 0xF0, 0x7C, 0x86, 0x70, 0x7F, 0x77, 0xF7, 0xC8, 0x90,
  0x80, 0x7F, 0x77, 0xF7, 0x07, 0xB8, 0x2D, 0x2F, 0x74, 0x07, 0x92, 0x98, 0x17, 0x07, 0x94, 0x0C,
  0x05, 0x40, 0x50, 0xC2, 0x83, 0xC5, 0x05, 0xC4,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_php() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 9, 21, 14), Box(0, 0, 23, 23),
      ic_round_24_action_php_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_picture_in_picture_alt 24x24, 4-bit Alpha,  RLE, 59 bytes.
static const unsigned char ic_round_24_action_picture_in_picture_alt_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xE0, 0xDA, 0x03, 0x77, 0x20, 0x3C, 0x77, 0x4C, 0x77,
  0x4C, 0x77, 0x4C, 0x77, 0x4C, 0x77, 0x4C, 0x71, 0x0B, 0xE0, 0xB2, 0xC7, 0x1F, 0x92, 0xC7, 0x1F,
  0x92, 0xC7, 0x1F, 0x92, 0xC7, 0x1F, 0x92, 0xC7, 0x10, 0xBE, 0x0B, 0x2C, 0x77, 0x4C, 0x03, 0x77,
  0x20, 0x3A, 0x0D, 0xFF, 0xE8, 0x1D, 0x4D, 0xFF, 0xC0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_picture_in_picture_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_picture_in_picture_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_picture_in_picture 24x24, 4-bit Alpha,  RLE, 59 bytes.
static const unsigned char ic_round_24_action_picture_in_picture_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xE0, 0xDA, 0x03, 0x77, 0x20, 0x3C, 0x77, 0x4C, 0x71,
  0x0B, 0xE0, 0xB2, 0xC7, 0x1F, 0x92, 0xC7, 0x1F, 0x92, 0xC7, 0x1F, 0x92, 0xC7, 0x1F, 0x92, 0xC7,
  0x10, 0xBE, 0x0B, 0x2C, 0x77, 0x4C, 0x77, 0x4C, 0x77, 0x4C, 0x77, 0x4C, 0x77, 0x4C, 0x03, 0x77,
  0x20, 0x3A, 0x0D, 0xFF, 0xE8, 0x1D, 0x4D, 0xFF, 0xC0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_picture_in_picture() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_picture_in_picture_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_pinch 24x24, 4-bit Alpha,  RLE, 101 bytes.
static const unsigned char ic_round_24_action_pinch_data[] PROGMEM = {
  0x50, 0xCB, 0x0B, 0x77, 0x38, 0x15, 0x7D, 0xA7, 0x74, 0x81, 0x8F, 0xD9, 0x77, 0x38, 0x28, 0xF8,
  0x79, 0x77, 0x28, 0x48, 0xF8, 0x05, 0xC2, 0x81, 0x8E, 0x87, 0x84, 0xC5, 0x08, 0xF8, 0x6B, 0x79,
  0x82, 0x78, 0xF8, 0x7B, 0x79, 0x81, 0xDF, 0x87, 0x1B, 0x7A, 0x81, 0xD7, 0x57, 0xB7, 0x0B, 0xB0,
  0xC7, 0xB7, 0x75, 0xB7, 0x75, 0xB0, 0x70, 0x57, 0x73, 0xD0, 0xE0, 0x67, 0x71, 0xF0, 0xE0, 0x67,
  0x6F, 0xA0, 0xA7, 0x82, 0x37, 0x41, 0x1F, 0xA0, 0xE7, 0x0B, 0xB0, 0xDF, 0xA0, 0xD7, 0x03, 0x0E,
  0xFD, 0x0B, 0x71, 0x03, 0x0E, 0xFC, 0x09, 0x72, 0x04, 0xFC, 0x07, 0x73, 0x05, 0xFB, 0x04, 0x74,
  0x05, 0x0D, 0xE0, 0xE0, 0x91,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_pinch() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_pinch_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_pin_end 24x24, 4-bit Alpha,  RLE, 68 bytes.
static const unsigned char ic_round_24_action_pin_end_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDA, 0x77, 0x2C, 0x77, 0x2C, 0x50, 0xEB, 0x0C,
  0x6C, 0x5B, 0x0E, 0x03, 0x6C, 0x5B, 0x0D, 0x01, 0x6C, 0x59, 0x83, 0xED, 0xFC, 0x15, 0xC5, 0x84,
  0xC3, 0x1C, 0xFB, 0x7A, 0x71, 0x81, 0x1B, 0x97, 0xA7, 0x68, 0x28, 0xDD, 0x81, 0xA7, 0x50, 0x8C,
  0x08, 0xA7, 0x50, 0xDC, 0x0D, 0xA7, 0x50, 0xDC, 0x00, 0xDF, 0xC2, 0x08, 0xC8, 0x18, 0x4D, 0xFB,
  0x38, 0x28, 0xDD, 0x81,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_pin_end() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_pin_end_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_pin_invoke 24x24, 4-bit Alpha,  RLE, 69 bytes.
static const unsigned char ic_round_24_action_pin_invoke_data[] PROGMEM = {
  0x04, 0x0D, 0xFB, 0x38, 0x48, 0xDD, 0x80, 0xDF, 0xC2, 0x08, 0xC0, 0x8A, 0x75, 0x0D, 0xC0, 0xDA,
  0x75, 0x0D, 0xC0, 0xDA, 0x75, 0x08, 0xC0, 0x8A, 0x76, 0x82, 0x8D, 0xD8, 0x1A, 0x60, 0xCB, 0x0E,
  0x7A, 0x60, 0x30, 0xEB, 0x7A, 0x60, 0x10, 0xDB, 0x5C, 0x58, 0x31, 0xCF, 0xDE, 0x95, 0xC5, 0x84,
  0xBF, 0xC1, 0x3C, 0x5C, 0x58, 0x19, 0xB1, 0x71, 0xC7, 0x72, 0xC7, 0x72, 0xA0, 0xDF, 0xFC, 0x81,
  0xD4, 0xDF, 0xFA, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_pin_invoke() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_pin_invoke_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_plagiarism 24x24, 4-bit Alpha,  RLE, 82 bytes.
static const unsigned char ic_round_24_action_plagiarism_data[] PROGMEM = {
  0x04, 0x0D, 0xF0, 0xE0, 0x65, 0x0D, 0xF9, 0x81, 0xDF, 0x74, 0xFA, 0x82, 0x1D, 0xF7, 0x3F, 0xA1,
  0x82, 0x1D, 0xF7, 0x2F, 0xA2, 0x82, 0x1D, 0xF7, 0x1F, 0xA3, 0x82, 0x1D, 0xF6, 0xFA, 0x03, 0x38,
  0x11, 0xDE, 0x80, 0xC1, 0xF8, 0x3A, 0x20, 0x2A, 0xFB, 0x0A, 0x50, 0xAF, 0xA8, 0x53, 0x08, 0xE8,
  0x03, 0xFA, 0x28, 0x3E, 0xFE, 0x01, 0xFA, 0x85, 0x30, 0x8E, 0x80, 0x3F, 0xA0, 0xB5, 0x02, 0x0E,
  0xFA, 0x85, 0xA3, 0x03, 0x20, 0x3F, 0xE8, 0x1E, 0x33, 0xFF, 0xE0, 0xDF, 0xF8, 0x1D, 0x4D, 0xFD,
  0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_plagiarism() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_plagiarism_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_play_for_work 24x24, 4-bit Alpha,  RLE, 56 bytes.
static const unsigned char ic_round_24_action_play_for_work_data[] PROGMEM = {
  0x50, 0x0B, 0x73, 0xA7, 0x3A, 0x73, 0xA7, 0x3A, 0x78, 0x13, 0x55, 0xA8, 0x15, 0x53, 0x40, 0x8E,
  0x07, 0x50, 0x8C, 0x09, 0x70, 0x8A, 0x09, 0x40, 0xA0, 0xC3, 0x00, 0x83, 0x83, 0xCA, 0xBF, 0x56,
  0x85, 0x5F, 0xB5, 0xFD, 0x14, 0x89, 0x51, 0xDF, 0x50, 0xBF, 0xD5, 0x11, 0x5D, 0xFB, 0x20, 0x10,
  0xCE, 0x0C, 0x01, 0x48, 0x45, 0xBE, 0xEB, 0x53,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_play_for_work() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(6, 5, 17, 19), Box(0, 0, 23, 23),
      ic_round_24_action_play_for_work_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_polymer 24x24, 4-bit Alpha,  RLE, 129 bytes.
static const unsigned char ic_round_24_action_polymer_data[] PROGMEM = {
  0x40, 0x4B, 0x0B, 0x50, 0x4C, 0x04, 0x71, 0x0C, 0xB0, 0x25, 0x0D, 0xC0, 0xC7, 0x06, 0xB0, 0x95,
  0x08, 0xE0, 0x66, 0x0E, 0xA0, 0xE0, 0x14, 0x03, 0xB0, 0xC0, 0xEA, 0x0E, 0x50, 0x8B, 0x07, 0x50,
  0xCB, 0x03, 0x07, 0xB0, 0x83, 0x01, 0xB0, 0xD5, 0x06, 0xB0, 0x82, 0x0D, 0xB0, 0x12, 0x0A, 0xB0,
  0x54, 0x01, 0x0E, 0xA0, 0xD3, 0x05, 0xB8, 0x1A, 0x03, 0xB0, 0xC5, 0x0A, 0xB0, 0x44, 0x0C, 0xB0,
  0x03, 0xB0, 0xC4, 0x04, 0xB0, 0xA5, 0x0C, 0xB8, 0x13, 0x0A, 0xB0, 0x53, 0x0D, 0xA0, 0xE0, 0x14,
  0x05, 0xB0, 0xA2, 0x01, 0xB0, 0xD2, 0x08, 0xB0, 0x65, 0x0D, 0xB0, 0x13, 0x08, 0xB0, 0x70, 0x3B,
  0x0C, 0x50, 0x7B, 0x08, 0x50, 0xEA, 0x0E, 0x0C, 0xB0, 0x34, 0x01, 0x0E, 0xA0, 0xE6, 0x06, 0xE0,
  0x85, 0x09, 0xB0, 0x67, 0x0C, 0xC0, 0xD5, 0x02, 0xB0, 0xC7, 0x10, 0x4C, 0x04, 0x50, 0xBB, 0x04,
  0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_polymer() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 4, 23, 19), Box(0, 0, 23, 23),
      ic_round_24_action_polymer_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_power_settings_new 24x24, 4-bit Alpha,  RLE, 101 bytes.
static const unsigned char ic_round_24_action_power_settings_new_data[] PROGMEM = {
  0x71, 0x00, 0xB7, 0x72, 0xA7, 0x30, 0x20, 0x44, 0xA4, 0x04, 0x02, 0x30, 0x20, 0xE9, 0x4A, 0x49,
  0x0E, 0x02, 0x28, 0x1B, 0xFA, 0x4A, 0x48, 0x5A, 0xFB, 0x04, 0xFE, 0x5A, 0x58, 0x4E, 0xF4, 0x9F,
  0x75, 0xA5, 0x84, 0x7F, 0x9D, 0xF2, 0x5A, 0x58, 0x22, 0xFD, 0xE9, 0x6A, 0x69, 0x00, 0xE9, 0x60,
  0x0B, 0x69, 0x82, 0xED, 0xF2, 0x75, 0x84, 0x3F, 0xD9, 0xF7, 0x75, 0x84, 0x7F, 0x93, 0xFE, 0x74,
  0x86, 0x1E, 0xF4, 0x0B, 0xFA, 0x73, 0x81, 0xBF, 0xB2, 0x82, 0x1E, 0xFA, 0x78, 0x31, 0xBF, 0xE2,
  0x38, 0x43, 0xEF, 0xE7, 0x32, 0x84, 0x37, 0xEF, 0xE3, 0x50, 0x10, 0xBF, 0x90, 0xB0, 0x27, 0x18,
  0x63, 0x9C, 0xEE, 0xD9, 0x35,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_power_settings_new() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_power_settings_new_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_pregnant_woman 24x24, 4-bit Alpha,  RLE, 41 bytes.
static const unsigned char ic_round_24_action_pregnant_woman_data[] PROGMEM = {
  0x18, 0x24, 0xDD, 0x44, 0x0D, 0xA0, 0xD4, 0x0D, 0xA0, 0xD4, 0x82, 0x4D, 0xD4, 0x75, 0x82, 0x7E,
  0xD8, 0x30, 0x7C, 0x08, 0x20, 0xDC, 0x0D, 0x2E, 0x0A, 0x1F, 0x09, 0xF0, 0xEF, 0xFF, 0xB0, 0xBE,
  0x0B, 0x2B, 0x5B, 0x5B, 0x5B, 0x58, 0x18, 0xE8, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_pregnant_woman() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(8, 2, 15, 21), Box(0, 0, 23, 23),
      ic_round_24_action_pregnant_woman_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_preview 24x24, 4-bit Alpha,  RLE, 88 bytes.
static const unsigned char ic_round_24_action_preview_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xC2, 0xF7, 0x7C, 0x77, 0xC4, 0x84, 0x6C,
  0xEE, 0xC6, 0x4C, 0x28, 0x90, 0x2D, 0xFE, 0x99, 0xEF, 0xD2, 0x2C, 0x18, 0x92, 0x2E, 0xFE, 0x25,
  0x52, 0xEF, 0xE2, 0x1C, 0x10, 0xAA, 0x09, 0x05, 0xA0, 0x50, 0x9A, 0x0A, 0x1C, 0x10, 0xAA, 0x09,
  0x05, 0xA0, 0x50, 0x9A, 0x0A, 0x1C, 0x18, 0x92, 0x2E, 0xFE, 0x25, 0x52, 0xEF, 0xE2, 0x1C, 0x28,
  0x90, 0x2D, 0xFE, 0x99, 0xEF, 0xD2, 0x2C, 0x48, 0x46, 0xCE, 0xEC, 0x64, 0xC7, 0x7C, 0x77, 0xA0,
  0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xF0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_preview() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_preview_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_print 24x24, 4-bit Alpha,  RLE, 62 bytes.
static const unsigned char ic_round_24_action_print_data[] PROGMEM = {
  0x40, 0xBF, 0xB0, 0xB7, 0x1F, 0xD7, 0x1F, 0xD7, 0x10, 0xBF, 0xB0, 0xB7, 0x77, 0x40, 0x80, 0xDF,
  0xF8, 0x2D, 0x80, 0x8F, 0xFC, 0x08, 0x0D, 0xFF, 0x98, 0x23, 0x3F, 0xDF, 0xFA, 0x00, 0x38, 0x0D,
  0x4F, 0x71, 0xE0, 0xDD, 0x71, 0xD8, 0x1D, 0x4D, 0xC7, 0x1C, 0x0D, 0x04, 0x4A, 0x71, 0xA7, 0x1A,
  0x03, 0x60, 0x3A, 0x71, 0x0D, 0xFB, 0x0D, 0x71, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_print() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_print_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_privacy_tip 24x24, 4-bit Alpha,  RLE, 82 bytes.
static const unsigned char ic_round_24_action_privacy_tip_data[] PROGMEM = {
  0x78, 0x25, 0xAA, 0x57, 0x50, 0x60, 0xDC, 0x0D, 0x06, 0x78, 0x11, 0x8E, 0xF9, 0x81, 0xE8, 0x12,
  0x01, 0x0A, 0xFF, 0x81, 0xA1, 0xCF, 0xFA, 0x0C, 0xFF, 0xFD, 0x00, 0x3F, 0xFA, 0x00, 0x38, 0x0D,
  0x0F, 0x0E, 0xF0, 0x03, 0xF0, 0xE0, 0xDF, 0x2F, 0x0D, 0x0B, 0xF2, 0xF0, 0xB0, 0x7F, 0x2F, 0x07,
  0x02, 0xF2, 0xF8, 0x12, 0x0A, 0xE0, 0x03, 0xE0, 0xA2, 0x02, 0xFF, 0x02, 0x30, 0x7F, 0xD0, 0x75,
  0x0A, 0xFB, 0x0A, 0x70, 0x9F, 0x90, 0x97, 0x20, 0x60, 0xEC, 0x0E, 0x06, 0x74, 0x84, 0x17, 0xCC,
  0x71, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_privacy_tip() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 1, 20, 22), Box(0, 0, 23, 23),
      ic_round_24_action_privacy_tip_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_private_connectivity 24x24, 4-bit Alpha,  RLE, 82 bytes.
static const unsigned char ic_round_24_action_private_connectivity_data[] PROGMEM = {
  0x68, 0x61, 0x7C, 0xEE, 0xC7, 0x17, 0x40, 0x50, 0xEE, 0x0E, 0x05, 0x72, 0x05, 0xC0, 0x09, 0xC0,
  0x57, 0x01, 0x0E, 0xB8, 0x25, 0x44, 0x5B, 0x0E, 0x01, 0x60, 0x7C, 0x1A, 0x1C, 0x07, 0x60, 0xCB,
  0x84, 0xA0, 0x77, 0x0A, 0xB0, 0xC3, 0x0B, 0xE6, 0xE0, 0x0B, 0xE2, 0x00, 0x62, 0xE0, 0xB3, 0x0C,
  0xB2, 0x00, 0x62, 0xB0, 0xC6, 0x07, 0xB6, 0xB0, 0x76, 0x01, 0x0E, 0xA8, 0x4A, 0x77, 0x77, 0xAA,
  0x0E, 0x01, 0x70, 0x5F, 0xB0, 0x57, 0x20, 0x50, 0xEE, 0x0E, 0x05, 0x74, 0x86, 0x17, 0xCE, 0xEC,
  0x71, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_private_connectivity() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 5, 21, 18), Box(0, 0, 23, 23),
      ic_round_24_action_private_connectivity_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_production_quantity_limits 24x24, 4-bit Alpha,  RLE, 115 bytes.
static const unsigned char ic_round_24_action_production_quantity_limits_data[] PROGMEM = {
  0x73, 0x00, 0xB7, 0x10, 0xBA, 0x07, 0x6A, 0x71, 0x0B, 0xA0, 0xE6, 0xA7, 0x38, 0x1B, 0xF7, 0x5A,
  0x60, 0x70, 0x22, 0x81, 0x4F, 0xD5, 0x00, 0xB5, 0x81, 0x8F, 0x83, 0x81, 0xCF, 0x67, 0x38, 0x21,
  0xEF, 0x33, 0x81, 0x5F, 0xD7, 0x38, 0x19, 0xFA, 0x58, 0x1D, 0xF5, 0x30, 0x0B, 0x30, 0x2A, 0x02,
  0x58, 0x16, 0xFC, 0x30, 0x0B, 0x38, 0x1A, 0xF9, 0x78, 0x1D, 0xF4, 0x68, 0x23, 0xFE, 0x17, 0x08,
  0xFB, 0x08, 0x71, 0x0D, 0xFA, 0x0A, 0x71, 0x81, 0x7F, 0xC7, 0x73, 0x81, 0xDF, 0x47, 0x73, 0x0D,
  0xFD, 0x0B, 0x60, 0x40, 0xDF, 0xC0, 0xB7, 0x77, 0x58, 0x24, 0xDD, 0x46, 0x82, 0x4D, 0xD4, 0x60,
  0xDA, 0x0D, 0x60, 0xDA, 0x0D, 0x60, 0xDA, 0x0D, 0x60, 0xDA, 0x0D, 0x68, 0x24, 0xDD, 0x46, 0x82,
  0x4D, 0xD4, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_production_quantity_limits() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_production_quantity_limits_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_published_with_changes 24x24, 4-bit Alpha,  RLE, 154 bytes.
static const unsigned char ic_round_24_action_published_with_changes_data[] PROGMEM = {
  0x18, 0x41, 0x77, 0x77, 0x64, 0x81, 0x8A, 0x57, 0x01, 0x0D, 0xC4, 0x0D, 0xA0, 0xD0, 0x56, 0x01,
  0x0E, 0xB4, 0x81, 0x16, 0xCA, 0x08, 0x50, 0x7C, 0x70, 0x6A, 0x08, 0x30, 0x4A, 0x06, 0x0D, 0x97,
  0x10, 0x4A, 0x04, 0x28, 0x4D, 0xF7, 0x01, 0xA7, 0x28, 0x56, 0xFD, 0x04, 0xFD, 0x73, 0x02, 0x05,
  0x28, 0x4C, 0xF5, 0x9F, 0x77, 0x28, 0x91, 0x3E, 0xF2, 0x06, 0xFA, 0xDF, 0x27, 0x18, 0x23, 0xEF,
  0xA2, 0x82, 0x2F, 0xDE, 0x93, 0x07, 0x04, 0x38, 0x23, 0xEF, 0xA4, 0x90, 0x0E, 0x92, 0x02, 0xA8,
  0x45, 0x03, 0xEF, 0xA5, 0x98, 0x2E, 0xDF, 0x22, 0x07, 0xA8, 0x27, 0xEF, 0xA5, 0x84, 0x2F, 0xDA,
  0xF6, 0x30, 0x7B, 0x0A, 0x68, 0x47, 0xF9, 0x5F, 0xC4, 0x81, 0x7F, 0xA7, 0x85, 0xDF, 0x40, 0xDF,
  0x64, 0x01, 0x48, 0x4A, 0x10, 0x7F, 0xD2, 0x04, 0xA0, 0x47, 0x19, 0x0D, 0x06, 0xA0, 0x43, 0x08,
  0xA0, 0x67, 0xC0, 0x75, 0x08, 0xA8, 0x1C, 0x61, 0x4B, 0x0E, 0x01, 0x60, 0x50, 0xDA, 0x0D, 0x4C,
  0x0D, 0x01, 0x78, 0x15, 0xA8, 0x48, 0x46, 0x77, 0x77, 0x11,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_published_with_changes() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_published_with_changes_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_query_builder 24x24, 4-bit Alpha,  RLE, 138 bytes.
static const unsigned char ic_round_24_action_query_builder_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x50, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x12, 0x6C, 0xA0, 0x85, 0x08, 0xA0, 0x67, 0x10, 0x6A, 0x08, 0x30, 0x4A, 0x04, 0x73, 0x04,
  0xA0, 0x42, 0x81, 0xDF, 0x65, 0x0D, 0x05, 0x58, 0x56, 0xFD, 0x05, 0xFC, 0x69, 0x07, 0x68, 0x4C,
  0xF5, 0xAF, 0x66, 0x90, 0x76, 0x84, 0x6F, 0x9D, 0xF2, 0x69, 0x07, 0x68, 0x22, 0xFD, 0xE9, 0x79,
  0x07, 0x79, 0x00, 0xE9, 0x78, 0x1E, 0xC2, 0x69, 0x82, 0xED, 0xF2, 0x68, 0x24, 0xDF, 0x84, 0x84,
  0x2F, 0xDA, 0xF6, 0x71, 0x82, 0x7F, 0xD4, 0x28, 0x46, 0xF9, 0x5F, 0xC7, 0x28, 0x12, 0xA7, 0x28,
  0x5C, 0xF5, 0x0D, 0xF6, 0x75, 0x81, 0x6F, 0xD2, 0x04, 0xA0, 0x47, 0x30, 0x4A, 0x04, 0x30, 0x8A,
  0x06, 0x71, 0x06, 0xA0, 0x85, 0x08, 0xA8, 0x1C, 0x62, 0x28, 0x12, 0x6C, 0xA0, 0x87, 0x05, 0x0D,
  0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_query_builder() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_query_builder_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_question_answer 24x24, 4-bit Alpha,  RLE, 63 bytes.
static const unsigned char ic_round_24_action_question_answer_data[] PROGMEM = {
  0x04, 0x0D, 0xFC, 0x0D, 0x04, 0x50, 0xDF, 0xE0, 0xD5, 0xFF, 0x95, 0xFF, 0x95, 0xFF, 0x92, 0x90,
  0xD0, 0x4F, 0xF9, 0x2A, 0x0D, 0xFF, 0x92, 0xFF, 0xC2, 0xFF, 0xC2, 0xFF, 0xB0, 0xD2, 0xFF, 0xA0,
  0xD0, 0x42, 0xE0, 0x77, 0x6D, 0x07, 0x76, 0x03, 0xC0, 0x72, 0xFF, 0xA0, 0x73, 0x0D, 0xFF, 0x94,
  0x04, 0x0D, 0xFF, 0x77, 0x20, 0x7B, 0x77, 0x30, 0x7A, 0x77, 0x40, 0x79, 0x77, 0x50, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_question_answer() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_question_answer_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_question_mark 24x24, 4-bit Alpha,  RLE, 68 bytes.
static const unsigned char ic_round_24_action_question_mark_data[] PROGMEM = {
  0x28, 0x46, 0xCE, 0xEC, 0x74, 0x0B, 0xE8, 0x2D, 0x10, 0xAB, 0x00, 0xBB, 0x84, 0xC0, 0xDF, 0xE2,
  0x20, 0x20, 0xDA, 0x82, 0x33, 0x93, 0x40, 0x8A, 0x06, 0x70, 0x7A, 0x06, 0x60, 0x10, 0xDA, 0x02,
  0x60, 0xBA, 0x09, 0x60, 0xCA, 0x0C, 0x60, 0xAA, 0x0C, 0x01, 0x50, 0x2A, 0x0E, 0x01, 0x60, 0x5A,
  0x08, 0x78, 0x21, 0xCD, 0x27, 0x77, 0x71, 0x82, 0x4D, 0xD4, 0x70, 0xDA, 0x0D, 0x70, 0xDA, 0x0D,
  0x78, 0x24, 0xDD, 0x44,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_question_mark() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(7, 3, 17, 21), Box(0, 0, 23, 23),
      ic_round_24_action_question_mark_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_quickreply 24x24, 4-bit Alpha,  RLE, 67 bytes.
static const unsigned char ic_round_24_action_quickreply_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x2D, 0x40, 0xDF, 0xFC, 0x0D, 0x1F, 0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x1F,
  0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x1F, 0xE0, 0x37, 0xFE, 0x71, 0xFE, 0x20, 0xEB, 0x09, 0x1F, 0xE2,
  0xC0, 0x51, 0xFE, 0x2B, 0x0E, 0x2F, 0xE2, 0xB0, 0x72, 0xFE, 0x2D, 0x01, 0xFE, 0x20, 0xEB, 0x0B,
  0x1B, 0x07, 0x76, 0xA0, 0x31, 0xA0, 0x77, 0x79, 0x0B, 0x29, 0x07, 0x77, 0x19, 0x03, 0x20, 0x77,
  0x72, 0x0B, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_quickreply() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 22, 21), Box(0, 0, 23, 23),
      ic_round_24_action_quickreply_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_receipt 24x24, 4-bit Alpha,  RLE, 68 bytes.
static const unsigned char ic_round_24_action_receipt_data[] PROGMEM = {
  0x8A, 0x27, 0x07, 0x70, 0x77, 0x07, 0x70, 0x77, 0x07, 0x70, 0x6F, 0xCA, 0x0C, 0xA0, 0xCA, 0x0C,
  0xA0, 0xCA, 0x0C, 0x80, 0xE6, 0xF0, 0x37, 0x30, 0x3E, 0x03, 0x73, 0x03, 0x80, 0xC6, 0xF0, 0x37,
  0x30, 0x3E, 0x03, 0x73, 0x03, 0x80, 0xC6, 0xF0, 0x37, 0x30, 0x3E, 0x03, 0x73, 0x03, 0x80, 0xE6,
  0xF0, 0xCA, 0x0C, 0xA0, 0xCA, 0x0C, 0xA0, 0xCA, 0x8A, 0x2C, 0xF7, 0x07, 0x70, 0x77, 0x07, 0x70,
  0x77, 0x07, 0x70, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_receipt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_receipt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_record_voice_over 24x24, 4-bit Alpha,  RLE, 120 bytes.
static const unsigned char ic_round_24_action_record_voice_over_data[] PROGMEM = {
  0x77, 0x40, 0x30, 0x47, 0x75, 0x01, 0xA0, 0x47, 0x75, 0x81, 0xDF, 0xD6, 0x84, 0x1A, 0xDD, 0xA1,
  0x70, 0x5A, 0x04, 0x40, 0x10, 0xEC, 0x0E, 0x01, 0x28, 0x14, 0xD7, 0x28, 0x1D, 0xF9, 0x40, 0xAE,
  0x0A, 0x28, 0x18, 0xFE, 0x28, 0x1A, 0xFD, 0x40, 0xDE, 0x0D, 0x20, 0x6A, 0x83, 0x30, 0x8F, 0xE4,
  0x0D, 0xE0, 0xD2, 0x06, 0xA8, 0x33, 0x08, 0xFE, 0x40, 0xAE, 0x0A, 0x28, 0x18, 0xFE, 0x28, 0x1B,
  0xFD, 0x40, 0x10, 0xEC, 0x0E, 0x01, 0x28, 0x14, 0xE7, 0x28, 0x1E, 0xF9, 0x58, 0x41, 0xAD, 0xDA,
  0x17, 0x05, 0xA0, 0x57, 0x74, 0x81, 0xDF, 0xD7, 0x74, 0x01, 0xA0, 0x44, 0x89, 0x02, 0x6A, 0xDE,
  0xFD, 0xA6, 0x25, 0x03, 0x04, 0x30, 0x30, 0xBF, 0xB0, 0xB0, 0x37, 0x04, 0xFF, 0x04, 0x60, 0xDF,
  0xF0, 0xD6, 0xFF, 0xA6, 0x0B, 0xFF, 0x0B, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_record_voice_over() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_record_voice_over_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_redeem 24x24, 4-bit Alpha,  RLE, 89 bytes.
static const unsigned char ic_round_24_action_redeem_data[] PROGMEM = {
  0x58, 0x28, 0xDE, 0x82, 0x82, 0x8E, 0xD8, 0x72, 0x08, 0xC0, 0x09, 0xC0, 0x87, 0x18, 0x2D, 0xF3,
  0x3C, 0x82, 0x33, 0xFD, 0x71, 0x82, 0xEF, 0x33, 0xC8, 0x23, 0x3F, 0xE4, 0x04, 0x0D, 0xFF, 0xA8,
  0x1D, 0x4D, 0xF9, 0x00, 0xDF, 0x90, 0xDA, 0x03, 0x30, 0x4A, 0x00, 0x3A, 0x04, 0x30, 0x3C, 0x38,
  0x21, 0xEF, 0x72, 0x82, 0x7F, 0xE1, 0x3C, 0x38, 0x17, 0xFB, 0x48, 0x1B, 0xF7, 0x3C, 0x38, 0x12,
  0x71, 0x48, 0x11, 0x82, 0x3C, 0x77, 0x2C, 0x77, 0x28, 0x0F, 0x4F, 0x77, 0x2C, 0x03, 0x77, 0x03,
  0xA0, 0xDF, 0xFC, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_redeem() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_redeem_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_remove_done 24x24, 4-bit Alpha,  RLE, 143 bytes.
static const unsigned char ic_round_24_action_remove_done_data[] PROGMEM = {
  0x30, 0x60, 0x47, 0x76, 0xA0, 0x57, 0x75, 0x07, 0xA0, 0x57, 0x75, 0x07, 0xA0, 0x57, 0x75, 0x07,
  0xA0, 0x55, 0x06, 0x04, 0x38, 0x11, 0x71, 0x60, 0x7A, 0x05, 0x38, 0x18, 0xFC, 0x28, 0x21, 0xCF,
  0x77, 0x07, 0xA0, 0x52, 0x87, 0xBF, 0x40, 0x1C, 0xFC, 0x17, 0x10, 0x7A, 0x05, 0x28, 0x53, 0x01,
  0xCF, 0xC1, 0x73, 0x07, 0xA0, 0x52, 0x83, 0x1C, 0xFC, 0x12, 0x81, 0x18, 0x23, 0x04, 0x07, 0x20,
  0x7A, 0x05, 0x28, 0x1B, 0xC1, 0x38, 0x26, 0xFD, 0x22, 0x81, 0xBF, 0xA2, 0x07, 0xA0, 0x52, 0x01,
  0x58, 0x7B, 0xFD, 0x20, 0x2E, 0xFA, 0x20, 0x7A, 0x05, 0x71, 0x89, 0x1B, 0xFD, 0x20, 0x2E, 0xFA,
  0x1C, 0xB0, 0x57, 0x18, 0x5B, 0xFD, 0x20, 0x2E, 0xB0, 0xC0, 0x7A, 0x05, 0x71, 0x81, 0xBF, 0xD2,
  0x85, 0x2E, 0xFC, 0x10, 0x7A, 0x05, 0x71, 0x0A, 0x04, 0x38, 0x12, 0x71, 0x30, 0x7A, 0x05, 0x77,
  0x50, 0x7A, 0x05, 0x77, 0x50, 0x7A, 0x05, 0x77, 0x58, 0x17, 0xFA, 0x77, 0x60, 0x30, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_remove_done() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 22, 21), Box(0, 0, 23, 23),
      ic_round_24_action_remove_done_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_remove_shopping_cart 24x24, 4-bit Alpha,  RLE, 136 bytes.
static const unsigned char ic_round_24_action_remove_shopping_cart_data[] PROGMEM = {
  0x01, 0x05, 0x77, 0x78, 0x17, 0xFB, 0x77, 0x68, 0x21, 0xDF, 0xB7, 0x76, 0x82, 0x2D, 0xFB, 0x20,
  0x5F, 0xD0, 0xB4, 0x82, 0x2D, 0xFB, 0x20, 0x6F, 0xC0, 0xC5, 0x82, 0x2D, 0xFB, 0x20, 0x6F, 0xB0,
  0x46, 0x05, 0xA0, 0xB2, 0x06, 0xF9, 0x0B, 0x71, 0x0D, 0xA0, 0xB2, 0x06, 0xF0, 0x37, 0x10, 0x5B,
  0x0B, 0x20, 0x6D, 0x0A, 0x73, 0x0D, 0xB0, 0xB2, 0x06, 0xC0, 0x27, 0x30, 0x8C, 0x0B, 0x20, 0x6A,
  0x08, 0x74, 0x0D, 0xD0, 0xB2, 0x06, 0x0A, 0x74, 0x81, 0x7F, 0xC2, 0x82, 0x2D, 0xFB, 0x77, 0x81,
  0xDF, 0x43, 0x82, 0x2D, 0xFB, 0x76, 0x0D, 0xFA, 0x0B, 0x75, 0x04, 0x0D, 0xFA, 0x0B, 0x77, 0x68,
  0x22, 0xDF, 0xB7, 0x38, 0x24, 0xDD, 0x46, 0x06, 0xA0, 0xB7, 0x20, 0xDA, 0x0D, 0x60, 0xDB, 0x0B,
  0x71, 0x0D, 0xA0, 0xD6, 0x0D, 0xC0, 0xB7, 0x82, 0x4D, 0xD4, 0x68, 0x54, 0xDD, 0x6D, 0xFB, 0x77,
  0x68, 0x22, 0xDF, 0x57, 0x76, 0x81, 0x17, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_remove_shopping_cart() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 1, 22, 23), Box(0, 0, 23, 23),
      ic_round_24_action_remove_shopping_cart_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_reorder 24x24, 4-bit Alpha,  RLE, 34 bytes.
static const unsigned char ic_round_24_action_reorder_data[] PROGMEM = {
  0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB8, 0x0C, 0x00, 0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB8,
  0x0C, 0x00, 0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB8, 0x0C, 0x00, 0x0B, 0xFF, 0xA0, 0x0B, 0xFF,
  0xA0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_reorder() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 5, 20, 18), Box(0, 0, 23, 23),
      ic_round_24_action_reorder_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_repartition 24x24, 4-bit Alpha,  RLE, 82 bytes.
static const unsigned char ic_round_24_action_repartition_data[] PROGMEM = {
  0x30, 0x05, 0x77, 0x28, 0x17, 0xFD, 0x77, 0x10, 0x7A, 0x05, 0x77, 0x05, 0xFF, 0x83, 0xD9, 0x10,
  0x5F, 0xFA, 0x82, 0xE1, 0x07, 0xA0, 0x57, 0x38, 0x22, 0xBF, 0x92, 0x81, 0x7F, 0xD7, 0x48, 0x11,
  0xFD, 0x30, 0x05, 0x74, 0x81, 0x1F, 0xE7, 0x71, 0x84, 0x1B, 0xF9, 0x0B, 0xFF, 0x98, 0x2D, 0x10,
  0xBF, 0xE8, 0x1D, 0x91, 0x80, 0xC4, 0x00, 0x8F, 0xFA, 0x08, 0x1F, 0xFC, 0x1A, 0x38, 0x1A, 0xF5,
  0x28, 0x15, 0xFA, 0x3A, 0x1A, 0x38, 0x1A, 0xF5, 0x28, 0x15, 0xFA, 0x3A, 0x1F, 0xFC, 0x10, 0x8F,
  0xFA, 0x08,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_repartition() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_repartition_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_report_problem 24x24, 4-bit Alpha,  RLE, 79 bytes.
static const unsigned char ic_round_24_action_report_problem_data[] PROGMEM = {
  0x73, 0x00, 0xB7, 0x75, 0x06, 0xA0, 0x67, 0x73, 0x01, 0x0E, 0xA0, 0xE0, 0x17, 0x72, 0x09, 0xC0,
  0x97, 0x71, 0x03, 0xE0, 0x27, 0x70, 0xBE, 0x0B, 0x76, 0x05, 0xF9, 0x05, 0x75, 0x0D, 0xB0, 0x03,
  0xB0, 0xD7, 0x40, 0x7C, 0x2C, 0x07, 0x72, 0x01, 0x0E, 0xC2, 0xC0, 0xE0, 0x17, 0x10, 0xAD, 0x00,
  0x3D, 0x0A, 0x70, 0x3F, 0xF0, 0x36, 0x0C, 0xFF, 0x0C, 0x50, 0x6F, 0x2F, 0x06, 0x30, 0x10, 0xEF,
  0x2F, 0x0E, 0x30, 0x8F, 0xFC, 0x81, 0x80, 0x1F, 0xFE, 0x81, 0x11, 0xEF, 0xFC, 0x0E, 0x01,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_report_problem() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_report_problem_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_request_page 24x24, 4-bit Alpha,  RLE, 54 bytes.
static const unsigned char ic_round_24_action_request_page_data[] PROGMEM = {
  0x04, 0x0D, 0xF0, 0xE0, 0x65, 0x0D, 0xFB, 0x07, 0x4F, 0xD0, 0x73, 0xFE, 0x07, 0x2F, 0xF0, 0x71,
  0xFF, 0x90, 0x6F, 0x00, 0x3E, 0x0E, 0xD0, 0x34, 0x03, 0xFB, 0x50, 0x3F, 0xB2, 0xFF, 0x50, 0x3F,
  0xB0, 0x35, 0xFF, 0x2F, 0xB0, 0x35, 0xFB, 0x03, 0x40, 0x3F, 0xD0, 0x03, 0x80, 0xC3, 0xF0, 0xDF,
  0xF8, 0x1D, 0x4D, 0xFD, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_request_page() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_request_page_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_restore_from_trash 24x24, 4-bit Alpha,  RLE, 57 bytes.
static const unsigned char ic_round_24_action_restore_from_trash_data[] PROGMEM = {
  0x30, 0x10, 0xCC, 0x0C, 0x01, 0x30, 0xBF, 0xD0, 0x0B, 0xFD, 0x0B, 0x77, 0x10, 0x40, 0xDF, 0x90,
  0xD0, 0x42, 0x0D, 0xFB, 0x0D, 0x2F, 0xD2, 0xD0, 0x08, 0xD2, 0xC0, 0x72, 0x07, 0xC2, 0xB0, 0x74,
  0x07, 0xB2, 0xA0, 0x76, 0x07, 0xA2, 0xC4, 0xC2, 0xC4, 0xC2, 0xC4, 0xC2, 0xC4, 0xC2, 0xFD, 0x20,
  0xDF, 0xB0, 0xD2, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_restore_from_trash() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 18, 20), Box(0, 0, 23, 23),
      ic_round_24_action_restore_from_trash_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_restore_page 24x24, 4-bit Alpha,  RLE, 85 bytes.
static const unsigned char ic_round_24_action_restore_page_data[] PROGMEM = {
  0x04, 0x0D, 0xF0, 0xE0, 0x65, 0x0D, 0xFB, 0x07, 0x4F, 0xD0, 0x73, 0xFE, 0x07, 0x2F, 0xF0, 0x71,
  0xFF, 0x90, 0x6D, 0x84, 0xB4, 0x10, 0x3A, 0xC0, 0xEA, 0x89, 0x09, 0xD7, 0x02, 0x66, 0x10, 0x7E,
  0x82, 0x71, 0x06, 0xC8, 0x15, 0x0A, 0xD0, 0x72, 0x0D, 0xC8, 0x1E, 0x13, 0xD0, 0x82, 0x01, 0x0D,
  0xC0, 0x61, 0xFF, 0x06, 0x1F, 0x0B, 0xD8, 0x1E, 0x13, 0xE8, 0x1D, 0x06, 0xB8, 0x2E, 0x50, 0xAF,
  0x86, 0x70, 0x26, 0x61, 0x07, 0xFA, 0x0B, 0x04, 0x20, 0x30, 0xA8, 0x0C, 0x1F, 0x0D, 0xFF, 0x81,
  0xD4, 0xDF, 0xD0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_restore_page() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_restore_page_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_restore 24x24, 4-bit Alpha,  RLE, 133 bytes.
static const unsigned char ic_round_24_action_restore_data[] PROGMEM = {
  0x71, 0x86, 0x49, 0xDE, 0xED, 0x93, 0x74, 0x02, 0x0B, 0xF9, 0x0B, 0x01, 0x71, 0x84, 0x3E, 0xFE,
  0x72, 0x28, 0x43, 0x7E, 0xFE, 0x36, 0x82, 0x2E, 0xFA, 0x78, 0x31, 0xBF, 0xE1, 0x58, 0x1B, 0xFA,
  0x73, 0x81, 0xBF, 0xB4, 0x81, 0x4F, 0xE5, 0x0C, 0x05, 0x48, 0x21, 0xEF, 0x33, 0x81, 0x9F, 0x75,
  0x90, 0x75, 0x81, 0x7F, 0x93, 0x81, 0xDF, 0x25, 0x90, 0x75, 0x81, 0x3F, 0xC3, 0x0E, 0x96, 0x90,
  0x76, 0x90, 0xE0, 0x2E, 0x02, 0x38, 0x1E, 0xD4, 0x48, 0x31, 0xFE, 0x07, 0xC0, 0x74, 0x83, 0x4D,
  0xFA, 0x12, 0x81, 0x3F, 0xD2, 0x07, 0xA0, 0x77, 0x81, 0x7E, 0x92, 0x81, 0x7F, 0x93, 0x00, 0x77,
  0x20, 0x01, 0x28, 0x1E, 0xF3, 0x77, 0x38, 0x1A, 0xFB, 0x70, 0x50, 0x87, 0x18, 0x2A, 0xFE, 0x27,
  0x83, 0xCF, 0xE7, 0x22, 0x84, 0x27, 0xEF, 0xE3, 0x71, 0x02, 0x0B, 0xF9, 0x0B, 0x02, 0x74, 0x86,
  0x49, 0xDF, 0xED, 0x93, 0x50,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_restore() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_restore_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_rocket_launch 24x24, 4-bit Alpha,  RLE, 131 bytes.
static const unsigned char ic_round_24_action_rocket_launch_data[] PROGMEM = {
  0x77, 0x18, 0x23, 0x67, 0x67, 0x68, 0x11, 0x8E, 0xC0, 0x67, 0x40, 0x60, 0xEE, 0x07, 0x73, 0x0A,
  0xF9, 0x06, 0x48, 0x49, 0xDB, 0x01, 0xBF, 0xA0, 0x33, 0x0B, 0xA8, 0x14, 0x0B, 0xA8, 0x2B, 0x11,
  0xBB, 0x0E, 0x30, 0xBA, 0x81, 0x90, 0x9B, 0x01, 0x20, 0x1B, 0x08, 0x20, 0xBA, 0x81, 0xE1, 0x3C,
  0x01, 0x20, 0x1A, 0x82, 0xE1, 0x02, 0xB8, 0x16, 0x0C, 0xC8, 0x2B, 0x11, 0xBA, 0x05, 0x38, 0x34,
  0xBE, 0x05, 0xFB, 0x09, 0x68, 0x11, 0x0B, 0xFA, 0x0B, 0x72, 0x04, 0xF9, 0x0B, 0x74, 0x05, 0xE0,
  0x87, 0x18, 0x48, 0xEE, 0x80, 0x5B, 0x83, 0xC3, 0x04, 0xB5, 0x07, 0xC8, 0x90, 0x80, 0x4B, 0x50,
  0x19, 0xFD, 0x50, 0xEC, 0x0E, 0x40, 0x70, 0xEA, 0x09, 0x40, 0x3D, 0x0E, 0x20, 0x10, 0xEB, 0x0B,
  0x50, 0x7D, 0x08, 0x30, 0xBA, 0x0B, 0x60, 0xBB, 0x0E, 0x07, 0x48, 0x14, 0xFB, 0x78, 0x25, 0xB8,
  0x47, 0x02, 0x71,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_rocket_launch() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_rocket_launch_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_rocket 24x24, 4-bit Alpha,  RLE, 101 bytes.
static const unsigned char ic_round_24_action_rocket_data[] PROGMEM = {
  0x70, 0x02, 0x76, 0x05, 0xA0, 0x57, 0x40, 0x3C, 0x03, 0x73, 0x0C, 0xC0, 0xC7, 0x20, 0x4E, 0x04,
  0x71, 0x0A, 0xE0, 0xA7, 0x10, 0xEE, 0x0E, 0x70, 0x2A, 0x82, 0xB1, 0x1B, 0xA0, 0x26, 0x05, 0xA0,
  0x12, 0x01, 0xA0, 0x56, 0x06, 0xA0, 0x12, 0x01, 0xA0, 0x66, 0x07, 0xA8, 0x2B, 0x11, 0xBA, 0x07,
  0x48, 0x11, 0x07, 0xF9, 0x86, 0x70, 0x10, 0x3E, 0x15, 0xF9, 0x86, 0x51, 0xE3, 0xDF, 0x43, 0xF9,
  0x82, 0x34, 0xFD, 0xA0, 0x71, 0xF9, 0x10, 0x7C, 0x81, 0xA0, 0xBE, 0x81, 0xB0, 0xAC, 0x81, 0xE0,
  0x6E, 0x81, 0x60, 0xED, 0x81, 0x51, 0xDC, 0x81, 0xD1, 0x4D, 0x0E, 0x06, 0x71, 0x06, 0x0E, 0xA0,
  0x40, 0x67, 0x50, 0x60, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_rocket() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_rocket_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_room 24x24, 4-bit Alpha,  RLE, 79 bytes.
static const unsigned char ic_round_24_action_room_data[] PROGMEM = {
  0x48, 0x62, 0x8C, 0xEE, 0xC8, 0x27, 0x09, 0xF9, 0x09, 0x50, 0xBF, 0xB0, 0xB3, 0x09, 0xFD, 0x81,
  0x90, 0x2F, 0xF0, 0x20, 0x8F, 0xF0, 0x80, 0xCD, 0x82, 0xB1, 0x1B, 0xD0, 0xC0, 0xED, 0x01, 0x20,
  0x1D, 0x0E, 0xE0, 0x12, 0x01, 0xE0, 0xDD, 0x82, 0xB1, 0x1B, 0xD0, 0xD0, 0x9F, 0xF0, 0x90, 0x2F,
  0xF8, 0x12, 0x0A, 0xFD, 0x0A, 0x20, 0x10, 0xEF, 0xB0, 0xE0, 0x13, 0x05, 0xFB, 0x05, 0x50, 0x8F,
  0x90, 0x87, 0x0A, 0xE0, 0xA7, 0x20, 0xAC, 0x0A, 0x74, 0x0A, 0xA0, 0xA7, 0x60, 0x07, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_room() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_room_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_rounded_corner 24x24, 4-bit Alpha,  RLE, 48 bytes.
static const unsigned char ic_round_24_action_rounded_corner_data[] PROGMEM = {
  0xA2, 0xA2, 0xD8, 0x1E, 0xB4, 0x2A, 0x2A, 0x2F, 0x90, 0x87, 0x70, 0x10, 0x7A, 0x04, 0x77, 0x18,
  0x17, 0xFB, 0xA7, 0x68, 0x11, 0xFE, 0xA7, 0x7A, 0x77, 0x2A, 0x77, 0x2C, 0x77, 0xC7, 0x7A, 0x80,
  0xC0, 0x0A, 0x77, 0xC7, 0x7A, 0x80, 0xC0, 0x0A, 0x2A, 0x2A, 0x2A, 0x2C, 0x2A, 0x2A, 0x2A, 0x2A,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_rounded_corner() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_rounded_corner_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_rowing 24x24, 4-bit Alpha,  RLE, 103 bytes.
static const unsigned char ic_round_24_action_rowing_data[] PROGMEM = {
  0x72, 0x82, 0x4D, 0xD4, 0x76, 0x0D, 0xA0, 0xD7, 0x60, 0xDA, 0x0D, 0x76, 0x82, 0x4D, 0xD4, 0x77,
  0x77, 0x28, 0x28, 0xEC, 0x27, 0x50, 0x9B, 0x0C, 0x74, 0x09, 0xD7, 0x20, 0x30, 0xCE, 0x68, 0x17,
  0xBD, 0xA0, 0xE0, 0xBC, 0x6C, 0x81, 0xA1, 0x7C, 0x68, 0x54, 0x7D, 0xFD, 0x16, 0xC7, 0x18, 0x42,
  0xDF, 0xD1, 0x9B, 0x71, 0x87, 0x31, 0xDF, 0xD1, 0x9F, 0xD7, 0x89, 0x07, 0xF7, 0x1D, 0xFD, 0x19,
  0x86, 0x07, 0xB8, 0x47, 0x1D, 0xFD, 0x16, 0x07, 0xA0, 0x73, 0x83, 0x1D, 0xFD, 0x14, 0x05, 0xA0,
  0x75, 0x01, 0x0D, 0xB0, 0x72, 0x81, 0x5F, 0x77, 0x01, 0xC0, 0x77, 0x5D, 0x05, 0x74, 0x07, 0xC0,
  0x57, 0x50, 0x7A, 0x07, 0x77, 0x00, 0x52,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_rowing() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 1, 20, 23), Box(0, 0, 23, 23),
      ic_round_24_action_rowing_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_rule 24x24, 4-bit Alpha,  RLE, 93 bytes.
static const unsigned char ic_round_24_action_rule_data[] PROGMEM = {
  0x77, 0x40, 0x80, 0x37, 0x73, 0x81, 0xBF, 0xA7, 0x40, 0x10, 0x63, 0x83, 0xBF, 0xD2, 0xBF, 0x0B,
  0x28, 0x90, 0x7F, 0xC1, 0xBF, 0xD2, 0x0B, 0xF0, 0xB2, 0x01, 0x0D, 0xB0, 0xD0, 0x27, 0x78, 0x31,
  0xDF, 0xD2, 0x77, 0x28, 0x11, 0x71, 0x77, 0x77, 0x78, 0x11, 0x71, 0x28, 0x11, 0x71, 0x75, 0x86,
  0x7F, 0xC1, 0x1C, 0xF7, 0x75, 0x89, 0x01, 0xCF, 0xCC, 0xFC, 0x10, 0xBF, 0x0B, 0x30, 0x10, 0xCA,
  0x0C, 0x01, 0x20, 0xBF, 0x0B, 0x30, 0x10, 0xCA, 0x0C, 0x01, 0x76, 0x86, 0x1C, 0xFC, 0xCF, 0xC1,
  0x75, 0x86, 0x7F, 0xC1, 0x1C, 0xF7, 0x75, 0x81, 0x17, 0x12, 0x81, 0x17, 0x11,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_rule() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_rule_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_satellite_alt 24x24, 4-bit Alpha,  RLE, 194 bytes.
static const unsigned char ic_round_24_action_satellite_alt_data[] PROGMEM = {
  0x77, 0x18, 0x26, 0xED, 0x37, 0x74, 0x07, 0xB0, 0xE0, 0x37, 0x72, 0x07, 0xA8, 0x35, 0x9F, 0xE3,
  0x77, 0x07, 0xA8, 0x5E, 0x30, 0x9F, 0xE3, 0x75, 0x02, 0xA8, 0x76, 0xCE, 0x30, 0x9F, 0xE1, 0x74,
  0x89, 0x24, 0xFD, 0x11, 0xCE, 0x30, 0xDF, 0x57, 0x28, 0x94, 0x23, 0x0B, 0xFD, 0x11, 0xCE, 0xAF,
  0xE1, 0x71, 0x07, 0xA8, 0x6A, 0x1C, 0xFD, 0x11, 0xEA, 0x04, 0x71, 0x07, 0xC0, 0xB0, 0xEA, 0x0D,
  0x09, 0xA0, 0x47, 0x10, 0x2F, 0x02, 0x0C, 0xB0, 0x47, 0x20, 0x3F, 0x83, 0xB1, 0x8A, 0x37, 0x18,
  0x22, 0x40, 0xAF, 0x07, 0x73, 0x07, 0xA8, 0x1B, 0x1B, 0xE0, 0x97, 0x20, 0x7A, 0x82, 0xDF, 0xCE,
  0xE0, 0x37, 0x10, 0x7A, 0x81, 0x61, 0xDA, 0x02, 0x0A, 0xB0, 0x42, 0x0C, 0x09, 0x28, 0x1B, 0xA6,
  0xB8, 0x90, 0xC1, 0x1D, 0xFC, 0x17, 0x93, 0x28, 0xA0, 0x6F, 0xB0, 0x2F, 0xDE, 0xF5, 0x4E, 0xC1,
  0x1D, 0xF8, 0x40, 0x6A, 0x89, 0x64, 0x07, 0xF9, 0xCF, 0x90, 0x4E, 0xC1, 0x9F, 0xA3, 0x0C, 0xA0,
  0x72, 0x89, 0x1D, 0xF4, 0x3E, 0xF9, 0x04, 0xEE, 0xA0, 0x33, 0x81, 0x9B, 0x42, 0x81, 0xAF, 0xB2,
  0x84, 0x3E, 0xF9, 0x0A, 0xA0, 0x47, 0x18, 0x2A, 0xFE, 0x23, 0x82, 0x3E, 0xFD, 0xA0, 0x46, 0x84,
  0x27, 0xDF, 0xE3, 0x58, 0x33, 0xEF, 0xE4, 0x60, 0xBB, 0x0B, 0x02, 0x78, 0x11, 0x51, 0x78, 0x2A,
  0xC9, 0x45,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_satellite_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 0, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_satellite_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_saved_search 24x24, 4-bit Alpha,  RLE, 115 bytes.
static const unsigned char ic_round_24_action_saved_search_data[] PROGMEM = {
  0x38, 0x53, 0xAD, 0xFD, 0x93, 0x73, 0x08, 0xF0, 0x97, 0x10, 0x8A, 0x83, 0x83, 0x03, 0x8A, 0x08,
  0x60, 0x3A, 0x03, 0x20, 0x52, 0x03, 0xA0, 0x35, 0x81, 0xAF, 0x83, 0x0D, 0x38, 0x18, 0xFA, 0x58,
  0x93, 0xDF, 0x32, 0x79, 0xF9, 0x72, 0x3F, 0xD5, 0x0E, 0x92, 0x06, 0xB0, 0x62, 0x90, 0xE5, 0x81,
  0xDF, 0x32, 0x81, 0xDF, 0xD2, 0x81, 0x3F, 0xD5, 0x89, 0x39, 0xF8, 0x03, 0xB2, 0xB3, 0x08, 0xF9,
  0x50, 0x3A, 0x03, 0x01, 0x30, 0x10, 0x3A, 0x03, 0x60, 0x8A, 0x83, 0x83, 0x03, 0x8A, 0x0E, 0x01,
  0x70, 0x8F, 0x82, 0xEF, 0xC1, 0x78, 0x92, 0x3A, 0xDF, 0xD9, 0x31, 0xCF, 0xC1, 0x77, 0x83, 0x1C,
  0xFC, 0x17, 0x78, 0x31, 0xCF, 0xC1, 0x77, 0x83, 0x1C, 0xFC, 0x17, 0x78, 0x21, 0xCF, 0x77, 0x71,
  0x81, 0x17, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_saved_search() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_saved_search_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_savings 24x24, 4-bit Alpha,  RLE, 85 bytes.
static const unsigned char ic_round_24_action_savings_data[] PROGMEM = {
  0x74, 0x83, 0x18, 0xDF, 0x77, 0x70, 0x20, 0xDB, 0x0E, 0x68, 0x12, 0x9D, 0xFB, 0x0B, 0x50, 0x40,
  0xEF, 0xD0, 0xC4, 0x01, 0x0E, 0xFF, 0x0B, 0x30, 0x9D, 0x03, 0x30, 0x3E, 0x82, 0xC7, 0x4D, 0xD0,
  0x33, 0x03, 0xFF, 0xF9, 0x00, 0x3D, 0x0D, 0xFD, 0x00, 0x3D, 0x0C, 0xFF, 0xD0, 0x9F, 0xFD, 0x06,
  0xFF, 0xD0, 0x3F, 0xFB, 0x82, 0xE7, 0x0E, 0xFF, 0x90, 0x53, 0x0B, 0xFF, 0x0D, 0x40, 0x7F, 0xF0,
  0x84, 0x03, 0xFF, 0x03, 0x50, 0xDC, 0x0D, 0x20, 0xDC, 0x0E, 0x60, 0x40, 0xDA, 0x0D, 0x04, 0x20,
  0x40, 0xDA, 0x0D, 0x04, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_savings() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_savings_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_schedule 24x24, 4-bit Alpha,  RLE, 138 bytes.
static const unsigned char ic_round_24_action_schedule_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x50, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x12, 0x6C, 0xA0, 0x85, 0x08, 0xA0, 0x67, 0x10, 0x6A, 0x08, 0x30, 0x4A, 0x04, 0x73, 0x04,
  0xA0, 0x42, 0x81, 0xDF, 0x65, 0x0D, 0x05, 0x58, 0x56, 0xFD, 0x05, 0xFC, 0x69, 0x07, 0x68, 0x4C,
  0xF5, 0xAF, 0x66, 0x90, 0x76, 0x84, 0x6F, 0x9D, 0xF2, 0x69, 0x07, 0x68, 0x22, 0xFD, 0xE9, 0x79,
  0x07, 0x79, 0x00, 0xE9, 0x78, 0x1E, 0xC2, 0x69, 0x82, 0xED, 0xF2, 0x68, 0x24, 0xDF, 0x84, 0x84,
  0x2F, 0xDA, 0xF6, 0x71, 0x82, 0x7F, 0xD4, 0x28, 0x46, 0xF9, 0x5F, 0xC7, 0x28, 0x12, 0xA7, 0x28,
  0x5C, 0xF5, 0x0D, 0xF6, 0x75, 0x81, 0x6F, 0xD2, 0x04, 0xA0, 0x47, 0x30, 0x4A, 0x04, 0x30, 0x8A,
  0x06, 0x71, 0x06, 0xA0, 0x85, 0x08, 0xA8, 0x1C, 0x62, 0x28, 0x12, 0x6C, 0xA0, 0x87, 0x05, 0x0D,
  0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_schedule() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_schedule_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_schedule_send 24x24, 4-bit Alpha,  RLE, 104 bytes.
static const unsigned char ic_round_24_action_schedule_send_data[] PROGMEM = {
  0x04, 0x05, 0x77, 0x38, 0x3E, 0xFE, 0x81, 0x77, 0xD0, 0xA0, 0x47, 0x5F, 0x0D, 0x06, 0x73, 0xFA,
  0x81, 0xE9, 0x27, 0x0D, 0xFC, 0x0B, 0x04, 0x58, 0x21, 0x59, 0xDE, 0x81, 0xE7, 0x27, 0x38, 0x41,
  0x59, 0xDF, 0xA7, 0x68, 0x31, 0x59, 0xDA, 0x28, 0x44, 0xBE, 0xEB, 0x42, 0x82, 0x15, 0x9D, 0xB0,
  0xE2, 0x08, 0xE8, 0x18, 0x0D, 0xE8, 0x17, 0x04, 0xB0, 0x80, 0x9B, 0x04, 0xF8, 0x12, 0x0B, 0xB0,
  0x07, 0xB0, 0xBF, 0x20, 0xEB, 0x00, 0x7B, 0x0E, 0xD0, 0xA0, 0x42, 0x0E, 0xB8, 0x1C, 0x1B, 0xA8,
  0x4E, 0xEF, 0xE8, 0x14, 0x0B, 0xC8, 0x5B, 0x1E, 0xFB, 0x45, 0x70, 0x4D, 0x0E, 0xA0, 0x47, 0x30,
  0x8E, 0x08, 0x75, 0x84, 0x4B, 0xEE, 0xB4, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_schedule_send() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 4, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_schedule_send_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_search_off 24x24, 4-bit Alpha,  RLE, 104 bytes.
static const unsigned char ic_round_24_action_search_off_data[] PROGMEM = {
  0x58, 0x53, 0xAD, 0xFD, 0x93, 0x74, 0x08, 0xF0, 0x87, 0x20, 0x8A, 0x83, 0x82, 0x13, 0x9A, 0x08,
  0x70, 0x3A, 0x03, 0x50, 0x4A, 0x03, 0x68, 0x1A, 0xF8, 0x78, 0x18, 0xF9, 0x68, 0x1D, 0xF3, 0x78,
  0x12, 0xFD, 0x77, 0x3A, 0x77, 0x28, 0x13, 0xFD, 0x40, 0xC0, 0x32, 0x03, 0x0C, 0x68, 0x18, 0xFA,
  0x48, 0x43, 0xE3, 0x3E, 0x35, 0x03, 0xA0, 0x35, 0x82, 0x3E, 0xE3, 0x40, 0x30, 0x8A, 0x0A, 0x68,
  0x23, 0xEE, 0x33, 0xC8, 0x2A, 0xFD, 0x13, 0x84, 0x3E, 0x33, 0xE3, 0x29, 0x86, 0xEA, 0x30, 0xDF,
  0xD1, 0x20, 0xC0, 0x32, 0x03, 0x0C, 0x78, 0x31, 0xDF, 0xD1, 0x77, 0x18, 0x31, 0xDF, 0xD1, 0x77,
  0x18, 0x21, 0xDF, 0xD7, 0x72, 0x81, 0x1D, 0xC0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_search_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 19, 19), Box(0, 0, 23, 23),
      ic_round_24_action_search_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_search 24x24, 4-bit Alpha,  RLE, 92 bytes.
static const unsigned char ic_round_24_action_search_data[] PROGMEM = {
  0x38, 0x53, 0xAD, 0xFD, 0x93, 0x72, 0x08, 0xF0, 0x87, 0x08, 0xA8, 0x38, 0x30, 0x38, 0xA0, 0x85,
  0x03, 0xA0, 0x35, 0x03, 0xA0, 0x34, 0x81, 0xAF, 0x87, 0x81, 0x8F, 0x94, 0x81, 0xDF, 0x37, 0x81,
  0x3F, 0xD4, 0x0E, 0x97, 0x2A, 0x48, 0x1D, 0xF3, 0x78, 0x13, 0xFD, 0x48, 0x19, 0xF8, 0x78, 0x18,
  0xFA, 0x40, 0x3A, 0x03, 0x50, 0x3A, 0x03, 0x50, 0x8A, 0x83, 0x83, 0x03, 0x8A, 0x0A, 0x70, 0x8F,
  0x82, 0xAF, 0xD1, 0x68, 0x92, 0x39, 0xDF, 0xDA, 0x30, 0xDF, 0xD1, 0x76, 0x83, 0x1D, 0xFD, 0x17,
  0x68, 0x31, 0xDF, 0xD1, 0x76, 0x82, 0x1D, 0xFD, 0x77, 0x81, 0x1D, 0xC0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_search() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 19, 19), Box(0, 0, 23, 23),
      ic_round_24_action_search_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_segment 24x24, 4-bit Alpha,  RLE, 25 bytes.
static const unsigned char ic_round_24_action_segment_data[] PROGMEM = {
  0x0B, 0xFF, 0xA0, 0x0B, 0xFF, 0xA0, 0xB8, 0x0F, 0x00, 0x0B, 0xFB, 0x0B, 0x60, 0xBF, 0xB0, 0xB8,
  0x0F, 0x00, 0x0B, 0xFB, 0x0B, 0x60, 0xBF, 0xB0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_segment() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 6, 20, 17), Box(0, 0, 23, 23),
      ic_round_24_action_segment_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_send_and_archive 24x24, 4-bit Alpha,  RLE, 102 bytes.
static const unsigned char ic_round_24_action_send_and_archive_data[] PROGMEM = {
  0x0C, 0x05, 0x77, 0x3A, 0x81, 0xE8, 0x17, 0x7D, 0x0A, 0x04, 0x75, 0xF0, 0xD0, 0x67, 0x3F, 0xA8,
  0x1E, 0x82, 0x7F, 0xD0, 0xB0, 0x45, 0x82, 0x15, 0x9D, 0xE8, 0x1E, 0x72, 0x73, 0x84, 0x15, 0x9D,
  0xFA, 0x76, 0x83, 0x15, 0x9D, 0xA2, 0x84, 0x4B, 0xEE, 0xB4, 0x28, 0x21, 0x59, 0xDB, 0x0E, 0x20,
  0x8E, 0x08, 0x1F, 0x81, 0x70, 0x4B, 0x00, 0x8B, 0x04, 0xF8, 0x12, 0x0B, 0xB0, 0x07, 0xB0, 0xBF,
  0x20, 0xEB, 0x00, 0x7B, 0x0E, 0xD0, 0xA0, 0x42, 0x81, 0xEF, 0xD4, 0x81, 0xCF, 0xEA, 0x81, 0xE8,
  0x14, 0x0B, 0xA0, 0x72, 0x07, 0xA8, 0x1B, 0xC5, 0x70, 0x4B, 0x00, 0x8B, 0x04, 0x73, 0x08, 0xE0,
  0x87, 0x58, 0x44, 0xBE, 0xEB, 0x42,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_send_and_archive() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 4, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_send_and_archive_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_sensors_off 24x24, 4-bit Alpha,  RLE, 151 bytes.
static const unsigned char ic_round_24_action_sensors_off_data[] PROGMEM = {
  0x10, 0x90, 0x67, 0x74, 0x01, 0xA0, 0x77, 0x74, 0x05, 0xA0, 0x77, 0x50, 0x50, 0x64, 0x08, 0xA0,
  0x77, 0x48, 0x1D, 0xF4, 0x30, 0xDB, 0x07, 0x73, 0x81, 0x6F, 0xD2, 0x82, 0x5F, 0xD5, 0xA0, 0x76,
  0x06, 0x09, 0x28, 0x7C, 0xF5, 0x0A, 0xF6, 0x08, 0xA0, 0x75, 0x89, 0x3B, 0xF5, 0x06, 0xFA, 0x0D,
  0xF3, 0x0C, 0xB0, 0x74, 0x89, 0x55, 0xFB, 0x02, 0xFD, 0x0E, 0xF1, 0x0E, 0xF6, 0xA0, 0x73, 0x81,
  0x1F, 0xE2, 0x98, 0x1E, 0x0E, 0x92, 0x82, 0xEF, 0x15, 0xA0, 0x72, 0x89, 0x71, 0xFE, 0x01, 0xFE,
  0x0D, 0xF2, 0x0B, 0xF5, 0x05, 0xA0, 0x72, 0x89, 0x4A, 0xC0, 0x3F, 0xD0, 0xAF, 0x60, 0x5F, 0xB2,
  0x05, 0xA0, 0x72, 0x87, 0x30, 0x6F, 0xA0, 0x5F, 0xC2, 0x09, 0x05, 0x30, 0x5A, 0x07, 0x38, 0x1D,
  0xF5, 0x28, 0x1D, 0xF6, 0x70, 0x5A, 0x07, 0x20, 0xA0, 0xD3, 0x81, 0x4F, 0xD7, 0x10, 0x5A, 0x07,
  0x20, 0x34, 0x06, 0x05, 0x72, 0x05, 0xA0, 0x77, 0x74, 0x05, 0xA0, 0x77, 0x74, 0x05, 0xA0, 0x67,
  0x74, 0x81, 0x5F, 0x97, 0x75, 0x01, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_sensors_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_sensors_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_sensors 24x24, 4-bit Alpha,  RLE, 118 bytes.
static const unsigned char ic_round_24_action_sensors_data[] PROGMEM = {
  0x20, 0x60, 0x57, 0x50, 0x50, 0x63, 0x81, 0x4F, 0xD7, 0x58, 0x1D, 0xF4, 0x28, 0x1D, 0xF6, 0x75,
  0x85, 0x6F, 0xD0, 0x5F, 0xC2, 0x09, 0x05, 0x60, 0x60, 0x92, 0x89, 0x0C, 0xF5, 0xAF, 0x60, 0x6F,
  0xB6, 0x8B, 0x2B, 0xF5, 0x06, 0xFA, 0xDF, 0x20, 0xBF, 0x50, 0x4D, 0xD4, 0x05, 0xFB, 0x02, 0xFD,
  0xE9, 0x28, 0x3E, 0xF1, 0x0D, 0xA8, 0x3D, 0x01, 0xFE, 0x29, 0x00, 0xE9, 0x28, 0x3E, 0xF1, 0x0D,
  0xA8, 0x3D, 0x01, 0xFE, 0x29, 0x8B, 0x2E, 0xDF, 0x20, 0xBF, 0x50, 0x4D, 0xD4, 0x05, 0xFB, 0x02,
  0xFD, 0xAF, 0x60, 0x5F, 0xB6, 0x89, 0x0B, 0xF5, 0x06, 0xFA, 0x5F, 0xC2, 0x09, 0x05, 0x60, 0x60,
  0x92, 0x85, 0xCF, 0x50, 0xDF, 0x67, 0x58, 0x16, 0xFD, 0x28, 0x14, 0xFD, 0x75, 0x81, 0xDF, 0x43,
  0x06, 0x05, 0x75, 0x05, 0x06, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_sensors() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 5, 21, 18), Box(0, 0, 23, 23),
      ic_round_24_action_sensors_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_accessibility 24x24, 4-bit Alpha,  RLE, 77 bytes.
static const unsigned char ic_round_24_action_settings_accessibility_data[] PROGMEM = {
  0x78, 0x24, 0xDD, 0x47, 0x70, 0xDA, 0x0D, 0x77, 0x0D, 0xA0, 0xD7, 0x78, 0x24, 0xDD, 0x47, 0x86,
  0x5B, 0x96, 0x42, 0x11, 0x28, 0x71, 0x12, 0x46, 0x9B, 0x5A, 0xFF, 0xA8, 0x5A, 0x05, 0x8A, 0xCE,
  0xE8, 0x4E, 0xCA, 0x85, 0x16, 0xE7, 0x5E, 0x75, 0xE7, 0x5E, 0x75, 0xE7, 0x5E, 0x75, 0xA2, 0xA7,
  0x5A, 0x2A, 0x75, 0xA2, 0xA7, 0x5A, 0x2A, 0x75, 0xA2, 0xA7, 0x50, 0x0B, 0x20, 0x0B, 0x80, 0xF4,
  0x00, 0x0B, 0x20, 0x0B, 0x20, 0x0B, 0x71, 0x00, 0xB2, 0x00, 0xB2, 0x00, 0xB4,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_accessibility() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 0, 20, 23), Box(0, 0, 23, 23),
      ic_round_24_action_settings_accessibility_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_applications 24x24, 4-bit Alpha,  RLE, 75 bytes.
static const unsigned char ic_round_24_action_settings_applications_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xC7, 0xF0, 0xE2, 0x0E, 0xFD, 0x81, 0xCF,
  0x72, 0x81, 0x7F, 0xCF, 0xA0, 0xA7, 0x10, 0xAF, 0x90, 0x72, 0x82, 0x4D, 0xD4, 0x20, 0x7F, 0xA8,
  0x13, 0x0D, 0xA8, 0x1D, 0x03, 0xFB, 0x81, 0x30, 0xDA, 0x81, 0xD0, 0x3F, 0xA0, 0x72, 0x82, 0x4D,
  0xD4, 0x20, 0x7F, 0x90, 0xA7, 0x10, 0xAF, 0xA8, 0x1C, 0xF8, 0x28, 0x17, 0xFC, 0xFD, 0x0E, 0x20,
  0xE8, 0x0C, 0x7F, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_applications() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_settings_applications_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_backup_restore 24x24, 4-bit Alpha,  RLE, 117 bytes.
static const unsigned char ic_round_24_action_settings_backup_restore_data[] PROGMEM = {
  0x58, 0x63, 0x9C, 0xEE, 0xD9, 0x35, 0x02, 0x20, 0x20, 0xBF, 0x90, 0xB0, 0x13, 0x98, 0x57, 0x3E,
  0xFE, 0x72, 0x28, 0x42, 0x7E, 0xFE, 0x32, 0xC0, 0xA0, 0x16, 0x83, 0x1A, 0xFE, 0x11, 0xB0, 0xC7,
  0x38, 0x1A, 0xFB, 0x1C, 0x07, 0x72, 0x83, 0x1E, 0xF3, 0xEC, 0x02, 0x72, 0x81, 0x7F, 0x97, 0x82,
  0x4D, 0xD4, 0x48, 0x13, 0xFC, 0x70, 0xDA, 0x0D, 0x59, 0x0E, 0x70, 0xDA, 0x0D, 0x48, 0x41, 0xFE,
  0x7D, 0x14, 0x82, 0x4D, 0xD4, 0x48, 0x43, 0xFD, 0x9F, 0x77, 0x58, 0x58, 0xF9, 0x4F, 0xE1, 0x73,
  0x86, 0x1E, 0xF4, 0x0B, 0xFA, 0x73, 0x81, 0xAF, 0xB2, 0x82, 0x2E, 0xFA, 0x78, 0x31, 0xAF, 0xE2,
  0x38, 0x43, 0xEF, 0xE7, 0x22, 0x84, 0x38, 0xEF, 0xE3, 0x50, 0x20, 0xBF, 0x90, 0xB0, 0x27, 0x18,
  0x64, 0x9D, 0xEE, 0xD9, 0x45,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_backup_restore() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_settings_backup_restore_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_bluetooth 24x24, 4-bit Alpha,  RLE, 116 bytes.
static const unsigned char ic_round_24_action_settings_bluetooth_data[] PROGMEM = {
  0x60, 0xC0, 0x77, 0x4A, 0x07, 0x73, 0xB0, 0x73, 0x81, 0x17, 0x13, 0xC0, 0x72, 0x82, 0x7F, 0xC1,
  0x2A, 0x05, 0xA8, 0x57, 0x01, 0xCF, 0xC1, 0x1A, 0x10, 0x6A, 0x85, 0x20, 0x1C, 0xFC, 0x1A, 0x82,
  0x1C, 0xFC, 0x38, 0x21, 0xCF, 0xCA, 0x82, 0xCF, 0xC1, 0x40, 0x10, 0xCC, 0x0C, 0x01, 0x60, 0x10,
  0xCA, 0x0C, 0x01, 0x70, 0x10, 0xCA, 0x0C, 0x01, 0x60, 0x10, 0xCC, 0x0C, 0x01, 0x48, 0x21, 0xCF,
  0xCA, 0x82, 0xCF, 0xC1, 0x28, 0x31, 0xCF, 0xC1, 0xA8, 0x90, 0x1C, 0xFC, 0x01, 0xCF, 0xC1, 0x1A,
  0x10, 0x6A, 0x83, 0x27, 0xFC, 0x12, 0xA0, 0x5A, 0x83, 0x70, 0x17, 0x13, 0xC0, 0x77, 0x1B, 0x07,
  0x72, 0xA0, 0x77, 0x30, 0xC0, 0x77, 0x77, 0x75, 0x00, 0xB2, 0x00, 0xB2, 0x00, 0xB3, 0x00, 0xB2,
  0x00, 0xB2, 0x00, 0xB1,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_bluetooth() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 0, 17, 23), Box(0, 0, 23, 23),
      ic_round_24_action_settings_bluetooth_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_brightness 24x24, 4-bit Alpha,  RLE, 72 bytes.
static const unsigned char ic_round_24_action_settings_brightness_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDF, 0xA0, 0x0E, 0xFF, 0xB8, 0x2D, 0x11, 0xDF,
  0xF0, 0x16, 0x01, 0xFD, 0x40, 0xD0, 0x82, 0xFC, 0x0D, 0x4A, 0x81, 0x80, 0xDF, 0xA0, 0xE0, 0x14,
  0xA8, 0x2D, 0x01, 0xEF, 0x90, 0xE0, 0x14, 0xA8, 0x2D, 0x01, 0xEF, 0xA0, 0xD4, 0xA8, 0x18, 0x0D,
  0xFC, 0x40, 0xD0, 0x82, 0xFD, 0x01, 0x60, 0x1F, 0xF8, 0x2D, 0x11, 0xDF, 0xFB, 0x00, 0xEF, 0xA0,
  0xDF, 0xFC, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_brightness() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_settings_brightness_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_cell 24x24, 4-bit Alpha,  RLE, 51 bytes.
static const unsigned char ic_round_24_action_settings_cell_data[] PROGMEM = {
  0x04, 0x0D, 0xF9, 0x81, 0xD4, 0xDF, 0xB0, 0xDF, 0xFF, 0xD7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7,
  0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xC7, 0x1C, 0x71, 0xFF, 0xFD, 0x0D, 0xFB, 0x81,
  0xD4, 0xDF, 0x90, 0xD0, 0x47, 0x77, 0x40, 0x0B, 0x20, 0x0B, 0x20, 0x0B, 0x20, 0x0B, 0x20, 0x0B,
  0x20, 0x0B, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_cell() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(6, 0, 17, 23), Box(0, 0, 23, 23),
      ic_round_24_action_settings_cell_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_ethernet 24x24, 4-bit Alpha,  RLE, 86 bytes.
static const unsigned char ic_round_24_action_settings_ethernet_data[] PROGMEM = {
  0x50, 0x05, 0x71, 0x00, 0x57, 0x28, 0x17, 0xFD, 0x71, 0x81, 0xDF, 0x77, 0x07, 0xA0, 0x57, 0x10,
  0x5A, 0x07, 0x50, 0x7A, 0x05, 0x73, 0x05, 0xA0, 0x73, 0x07, 0xA0, 0x57, 0x50, 0x5A, 0x81, 0x70,
  0x5A, 0x05, 0x20, 0x0B, 0x20, 0x0B, 0x20, 0x0B, 0x20, 0x5A, 0x00, 0x5A, 0x05, 0x20, 0x0B, 0x20,
  0x0B, 0x20, 0x0B, 0x20, 0x5A, 0x81, 0x50, 0x7A, 0x05, 0x75, 0x05, 0xA0, 0x73, 0x07, 0xA0, 0x57,
  0x30, 0x5A, 0x07, 0x50, 0x7A, 0x05, 0x71, 0x05, 0xA0, 0x77, 0x81, 0x7F, 0xD7, 0x18, 0x1D, 0xF7,
  0x72, 0x00, 0x57, 0x10, 0x05, 0x50,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_ethernet() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 6, 22, 17), Box(0, 0, 23, 23),
      ic_round_24_action_settings_ethernet_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_input_antenna 24x24, 4-bit Alpha,  RLE, 159 bytes.
static const unsigned char ic_round_24_action_settings_input_antenna_data[] PROGMEM = {
  0x68, 0x90, 0x16, 0xAD, 0xEE, 0xDA, 0x61, 0x74, 0x07, 0x0E, 0xF9, 0x0E, 0x07, 0x71, 0x01, 0x0C,
  0xA8, 0x1B, 0x62, 0x28, 0x12, 0x6B, 0xA0, 0xC0, 0x15, 0x83, 0x1D, 0xFD, 0x37, 0x18, 0x33, 0xDF,
  0xD1, 0x48, 0x1C, 0xFB, 0x28, 0x61, 0x7C, 0xEE, 0xC7, 0x12, 0x81, 0xBF, 0xC3, 0x85, 0x7F, 0xD1,
  0x05, 0xEE, 0x85, 0xE5, 0x01, 0xDF, 0x72, 0x83, 0xEF, 0x30, 0x5A, 0x84, 0xB4, 0x11, 0x4B, 0xA8,
  0x94, 0x50, 0x3F, 0xE0, 0x6F, 0xB0, 0x1E, 0xF8, 0x68, 0x95, 0x8F, 0xE1, 0x0B, 0xF6, 0xAF, 0x50,
  0x7F, 0xB3, 0x81, 0x65, 0x12, 0x89, 0x7B, 0xF7, 0x05, 0xFA, 0xDF, 0x20, 0xCF, 0x40, 0x1D, 0xA8,
  0x92, 0xD1, 0x04, 0xFC, 0x02, 0xFD, 0xBB, 0x20, 0xA0, 0xC2, 0x05, 0xC0, 0x62, 0x0C, 0x0A, 0x20,
  0x0B, 0x71, 0x06, 0xC0, 0x67, 0x72, 0x01, 0x0D, 0xA0, 0xD0, 0x17, 0x73, 0x01, 0xA7, 0x76, 0xA7,
  0x76, 0xA7, 0x75, 0x01, 0xA0, 0x17, 0x73, 0x01, 0x0C, 0xA0, 0xC0, 0x17, 0x71, 0x86, 0x1C, 0xFC,
  0xCF, 0xC1, 0x77, 0x86, 0xBF, 0xC1, 0x1C, 0xFB, 0x77, 0x81, 0xAB, 0x12, 0x81, 0x1B, 0xA7,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_input_antenna() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 21), Box(0, 0, 23, 23),
      ic_round_24_action_settings_input_antenna_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_input_component 24x24, 4-bit Alpha,  RLE, 89 bytes.
static const unsigned char ic_round_24_action_settings_input_component_data[] PROGMEM = {
  0x20, 0x0B, 0x60, 0x0B, 0x60, 0x0B, 0x4A, 0x6A, 0x6A, 0x4A, 0x6A, 0x6A, 0x4A, 0x6A, 0x6A, 0x4A,
  0x6A, 0x6A, 0x20, 0xBC, 0x0B, 0x20, 0xBC, 0x0B, 0x20, 0xBC, 0x0B, 0xE2, 0xE2, 0xFD, 0x2E, 0x2F,
  0xD2, 0xE2, 0xFD, 0x2E, 0x2F, 0xD2, 0xE2, 0xE8, 0x0D, 0x00, 0xE2, 0xE2, 0xFD, 0x2E, 0x2E, 0x0E,
  0xC0, 0xE2, 0x0E, 0xC0, 0xE2, 0x0E, 0xC0, 0xE0, 0x8C, 0x08, 0x20, 0x8C, 0x08, 0x20, 0x8C, 0x81,
  0x80, 0x8A, 0x08, 0x40, 0x8A, 0x08, 0x40, 0x8A, 0x08, 0x3A, 0x6A, 0x6A, 0x4A, 0x6A, 0x6A, 0x4A,
  0x6A, 0x6A, 0x40, 0x0B, 0x60, 0x0B, 0x60, 0x0B, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_input_component() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_settings_input_component_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_input_composite 24x24, 4-bit Alpha,  RLE, 89 bytes.
static const unsigned char ic_round_24_action_settings_input_composite_data[] PROGMEM = {
  0x20, 0x0B, 0x60, 0x0B, 0x60, 0x0B, 0x4A, 0x6A, 0x6A, 0x4A, 0x6A, 0x6A, 0x4A, 0x6A, 0x6A, 0x4A,
  0x6A, 0x6A, 0x20, 0xBC, 0x0B, 0x20, 0xBC, 0x0B, 0x20, 0xBC, 0x0B, 0xE2, 0xE2, 0xFD, 0x2E, 0x2F,
  0xD2, 0xE2, 0xFD, 0x2E, 0x2F, 0xD2, 0xE2, 0xE8, 0x0D, 0x00, 0xE2, 0xE2, 0xFD, 0x2E, 0x2E, 0x0E,
  0xC0, 0xE2, 0x0E, 0xC0, 0xE2, 0x0E, 0xC0, 0xE0, 0x8C, 0x08, 0x20, 0x8C, 0x08, 0x20, 0x8C, 0x81,
  0x80, 0x8A, 0x08, 0x40, 0x8A, 0x08, 0x40, 0x8A, 0x08, 0x3A, 0x6A, 0x6A, 0x4A, 0x6A, 0x6A, 0x4A,
  0x6A, 0x6A, 0x40, 0x0B, 0x60, 0x0B, 0x60, 0x0B, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_input_composite() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_settings_input_composite_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_input_hdmi 24x24, 4-bit Alpha,  RLE, 54 bytes.
static const unsigned char ic_round_24_action_settings_input_hdmi_data[] PROGMEM = {
  0x10, 0x40, 0xDF, 0x90, 0xD0, 0x42, 0x0D, 0xFB, 0x0D, 0x2A, 0x71, 0xA2, 0xA2, 0x0D, 0x20, 0xD2,
  0xA2, 0xA2, 0x92, 0x92, 0xA1, 0x0B, 0xFD, 0x0B, 0x80, 0x98, 0x2F, 0x0A, 0xFD, 0x0A, 0x03, 0xFD,
  0x81, 0x30, 0xBF, 0xB0, 0xB2, 0x03, 0xFB, 0x03, 0x30, 0xBF, 0x90, 0xB4, 0x03, 0xF9, 0x03, 0x5F,
  0x96, 0xF9, 0x60, 0xBE, 0x0B, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_input_hdmi() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 2, 18, 21), Box(0, 0, 23, 23),
      ic_round_24_action_settings_input_hdmi_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_input_svideo 24x24, 4-bit Alpha,  RLE, 157 bytes.
static const unsigned char ic_round_24_action_settings_input_svideo_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x12, 0x6C, 0xA0, 0x85, 0x08, 0xA0, 0x67, 0x10, 0x6A, 0x08, 0x30, 0x4A, 0x04, 0x20, 0x8C,
  0x08, 0x20, 0x4A, 0x04, 0x28, 0x1D, 0xF6, 0x30, 0xEC, 0x0E, 0x38, 0x56, 0xFD, 0x05, 0xFC, 0x40,
  0x8C, 0x08, 0x48, 0x4C, 0xF5, 0x9F, 0x67, 0x78, 0x90, 0x6F, 0x9D, 0xF2, 0x08, 0xE8, 0x68, 0x68,
  0xE8, 0x02, 0xFD, 0xE9, 0x28, 0x1E, 0xFE, 0x68, 0x1E, 0xFE, 0x29, 0x00, 0xE9, 0x28, 0x18, 0xE8,
  0x68, 0x18, 0xE8, 0x29, 0x82, 0xED, 0xF2, 0x77, 0x84, 0x2F, 0xD9, 0xF6, 0x30, 0x05, 0x40, 0x05,
  0x38, 0x46, 0xF9, 0x5F, 0xC2, 0x05, 0xA0, 0x52, 0x05, 0xA0, 0x52, 0x87, 0xCF, 0x50, 0xDF, 0x60,
  0x5A, 0x05, 0x20, 0x5A, 0x83, 0x50, 0x6F, 0xD2, 0x04, 0xA8, 0x24, 0x05, 0x54, 0x82, 0x55, 0x04,
  0xA0, 0x43, 0x08, 0xA0, 0x67, 0x10, 0x6A, 0x08, 0x50, 0x8A, 0x81, 0xC6, 0x22, 0x81, 0x26, 0xCA,
  0x08, 0x70, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x38, 0x65, 0x9D, 0xEE, 0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_input_svideo() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_settings_input_svideo_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_overscan 24x24, 4-bit Alpha,  RLE, 60 bytes.
static const unsigned char ic_round_24_action_settings_overscan_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDA, 0x77, 0x2C, 0x70, 0x07, 0x7C, 0x60, 0x7A,
  0x07, 0x6C, 0x77, 0x2C, 0x20, 0x77, 0x30, 0x72, 0xC1, 0x07, 0x97, 0x39, 0x07, 0x1C, 0x10, 0x79,
  0x73, 0x90, 0x71, 0xC2, 0x07, 0x73, 0x07, 0x2C, 0x77, 0x2C, 0x60, 0x7A, 0x07, 0x6C, 0x70, 0x07,
  0x7C, 0x77, 0x2A, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_overscan() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_settings_overscan_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_phone 24x24, 4-bit Alpha,  RLE, 86 bytes.
static const unsigned char ic_round_24_action_settings_phone_data[] PROGMEM = {
  0x0B, 0xC0, 0xD7, 0x50, 0xED, 0x04, 0x74, 0x0C, 0xD0, 0x77, 0x40, 0xAD, 0x0A, 0x74, 0x06, 0xD0,
  0xD7, 0x40, 0x2D, 0x07, 0x75, 0x0B, 0xB0, 0x72, 0x00, 0xB2, 0x00, 0xB2, 0x82, 0xBB, 0x05, 0xA0,
  0x73, 0x00, 0xB2, 0x00, 0xB2, 0x00, 0xB2, 0x81, 0xCF, 0x77, 0x71, 0x03, 0xA0, 0x37, 0x71, 0x82,
  0x8F, 0xD1, 0x77, 0x18, 0x2B, 0xFC, 0x14, 0x83, 0x6D, 0xA7, 0x45, 0x83, 0x1C, 0xFD, 0x32, 0x07,
  0xD0, 0xD5, 0x01, 0x0B, 0xA0, 0x07, 0xF7, 0x08, 0xFB, 0x71, 0x03, 0x0C, 0xF9, 0x73, 0x05, 0x0B,
  0xE7, 0x58, 0x41, 0x6A, 0xCE, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_phone() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_settings_phone_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings 24x24, 4-bit Alpha,  RLE, 101 bytes.
static const unsigned char ic_round_24_action_settings_data[] PROGMEM = {
  0x70, 0x9C, 0x09, 0x77, 0x0E, 0xC0, 0xE7, 0x60, 0x1E, 0x01, 0x71, 0x83, 0xBF, 0x93, 0x9E, 0x83,
  0x93, 0x9F, 0xB3, 0x05, 0xFF, 0xA0, 0x52, 0x0D, 0xFF, 0xA8, 0x1D, 0x07, 0xF8, 0x2D, 0x99, 0xDF,
  0x07, 0x08, 0xE0, 0xA4, 0x09, 0xE8, 0x18, 0x08, 0xC0, 0xD6, 0x0D, 0xC0, 0x83, 0x08, 0xB0, 0x96,
  0x08, 0xB0, 0x84, 0x08, 0xB0, 0x96, 0x08, 0xB0, 0x83, 0x08, 0xC0, 0xD6, 0x0D, 0xC8, 0x18, 0x08,
  0xE0, 0xA4, 0x09, 0xE0, 0x80, 0x7F, 0x82, 0xD9, 0x9D, 0xF8, 0x17, 0x0D, 0xFF, 0xA0, 0xD2, 0x05,
  0xFF, 0xA0, 0x53, 0x83, 0xBF, 0x93, 0x9E, 0x83, 0x93, 0x9F, 0xB7, 0x10, 0x1E, 0x77, 0x0E, 0xC0,
  0xE7, 0x70, 0x9C, 0x09, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_settings_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_power 24x24, 4-bit Alpha,  RLE, 105 bytes.
static const unsigned char ic_round_24_action_settings_power_data[] PROGMEM = {
  0x70, 0x0B, 0x77, 0xA7, 0x30, 0x13, 0xA3, 0x01, 0x58, 0x1B, 0xF4, 0x2A, 0x28, 0x14, 0xFB, 0x38,
  0x28, 0xFD, 0x12, 0xA2, 0x84, 0x1E, 0xF8, 0x02, 0xA0, 0x33, 0xA3, 0x03, 0xA8, 0x22, 0x8F, 0x94,
  0xA4, 0x84, 0x9F, 0x8C, 0xF3, 0x4A, 0x48, 0x23, 0xFC, 0xE9, 0x5A, 0x59, 0x00, 0xE9, 0x50, 0x0B,
  0x48, 0x41, 0xFE, 0xCF, 0x37, 0x38, 0x43, 0xFC, 0x8F, 0x87, 0x38, 0x29, 0xF8, 0x2A, 0x02, 0x71,
  0x03, 0xA8, 0x42, 0x08, 0xFE, 0x26, 0x82, 0x3D, 0xF8, 0x30, 0xBA, 0x08, 0x03, 0x20, 0x30, 0x9A,
  0x0B, 0x50, 0x8F, 0x90, 0x87, 0x86, 0x28, 0xCE, 0xEC, 0x82, 0x80, 0xE3, 0x00, 0x0B, 0x20, 0x0B,
  0x20, 0x0B, 0x60, 0x0B, 0x20, 0x0B, 0x20, 0x0B, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_power() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 23), Box(0, 0, 23, 23),
      ic_round_24_action_settings_power_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_remote 24x24, 4-bit Alpha,  RLE, 90 bytes.
static const unsigned char ic_round_24_action_settings_remote_data[] PROGMEM = {
  0x48, 0x66, 0xAD, 0xEE, 0xDA, 0x66, 0x07, 0x0E, 0xF9, 0x0E, 0x07, 0x20, 0x10, 0xCA, 0x81, 0xB5,
  0x22, 0x81, 0x25, 0xBA, 0x84, 0xC1, 0x3F, 0xD3, 0x71, 0x84, 0x3D, 0xF3, 0x02, 0x28, 0x11, 0x8C,
  0xA8, 0x1C, 0x81, 0x20, 0x24, 0x03, 0x0E, 0xE0, 0xE0, 0x36, 0x89, 0x05, 0xFB, 0x41, 0x14, 0xBF,
  0x58, 0x0C, 0x30, 0x0B, 0xE0, 0xB7, 0x1F, 0x97, 0x1B, 0x00, 0xDB, 0x71, 0xA0, 0xD2, 0x0D, 0xA7,
  0x1A, 0x0D, 0x20, 0xDA, 0x71, 0xB0, 0x0D, 0xB7, 0x1F, 0x97, 0x1F, 0x97, 0x1F, 0x97, 0x1F, 0x97,
  0x1F, 0x97, 0x1F, 0x97, 0x1F, 0x97, 0x10, 0xBE, 0x0B, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_remote() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 0, 19, 22), Box(0, 0, 23, 23),
      ic_round_24_action_settings_remote_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_settings_voice 24x24, 4-bit Alpha,  RLE, 86 bytes.
static const unsigned char ic_round_24_action_settings_voice_data[] PROGMEM = {
  0x58, 0x28, 0xDD, 0x87, 0x20, 0x8C, 0x08, 0x71, 0x0D, 0xC0, 0xD7, 0x1E, 0x71, 0xE7, 0x1E, 0x71,
  0xE7, 0x1E, 0x71, 0xE4, 0x0A, 0x0C, 0x20, 0xDC, 0x0D, 0x28, 0x5C, 0xAC, 0xF4, 0x08, 0xC8, 0x68,
  0x04, 0xFC, 0x7F, 0xB2, 0x82, 0x8D, 0xD8, 0x28, 0x5B, 0xF7, 0x1E, 0xF8, 0x68, 0x48, 0xFE, 0x10,
  0x4A, 0x84, 0xB4, 0x11, 0x4B, 0xA0, 0x43, 0x04, 0x0D, 0xE0, 0xD0, 0x45, 0x81, 0x17, 0xBA, 0x81,
  0xB7, 0x17, 0x2A, 0x75, 0xA7, 0x50, 0x0B, 0x80, 0xC0, 0x00, 0x0B, 0x20, 0x0B, 0x20, 0x0B, 0x40,
  0x0B, 0x20, 0x0B, 0x20, 0x0B, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_settings_voice() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 1, 18, 23), Box(0, 0, 23, 23),
      ic_round_24_action_settings_voice_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_shop_2 24x24, 4-bit Alpha,  RLE, 75 bytes.
static const unsigned char ic_round_24_action_shop_2_data[] PROGMEM = {
  0x72, 0x04, 0x0D, 0xC0, 0xD0, 0x47, 0x70, 0xDE, 0x0D, 0x77, 0xA4, 0xA7, 0x7A, 0x4A, 0x72, 0xFF,
  0xC4, 0xFF, 0xC4, 0xFF, 0xC4, 0xF0, 0x80, 0xDF, 0xA0, 0x0B, 0x2F, 0x20, 0x9F, 0xB2, 0xF3, 0x03,
  0x0D, 0xF9, 0x2F, 0x40, 0x1F, 0x92, 0xF3, 0x03, 0x0D, 0xF9, 0x2F, 0x20, 0x9F, 0xB2, 0xF0, 0x80,
  0xDF, 0xC2, 0xFF, 0xE2, 0x0D, 0xFF, 0xA0, 0xDA, 0x20, 0x40, 0xDF, 0xF0, 0xD0, 0x4A, 0x77, 0x6A,
  0x77, 0x60, 0xDF, 0xFA, 0x0B, 0x40, 0x40, 0xDF, 0xF9, 0x0B, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_shop_2() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 21), Box(0, 0, 23, 23),
      ic_round_24_action_shop_2_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_shopping_bag 24x24, 4-bit Alpha,  RLE, 50 bytes.
static const unsigned char ic_round_24_action_shopping_bag_data[] PROGMEM = {
  0x58, 0x41, 0xAD, 0xDA, 0x17, 0x20, 0x10, 0xEC, 0x0E, 0x01, 0x71, 0x86, 0xAF, 0xB1, 0x1B, 0xFA,
  0x71, 0x81, 0xDF, 0x12, 0x81, 0x1F, 0xD4, 0x04, 0x0D, 0xFD, 0x81, 0xD4, 0xDF, 0xF0, 0xDC, 0x2C,
  0x2F, 0x92, 0xC2, 0xF9, 0x00, 0x3C, 0x00, 0x38, 0x0A, 0xA0, 0xF0, 0xDF, 0xF8, 0x1D, 0x4D, 0xFD,
  0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_shopping_bag() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 2, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_shopping_bag_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_shopping_basket 24x24, 4-bit Alpha,  RLE, 92 bytes.
static const unsigned char ic_round_24_action_shopping_basket_data[] PROGMEM = {
  0x73, 0x00, 0xC7, 0x75, 0x08, 0xA0, 0x87, 0x73, 0x03, 0xC0, 0x37, 0x72, 0x84, 0xDF, 0x78, 0xFD,
  0x77, 0x18, 0x18, 0xFC, 0x28, 0x1D, 0xF8, 0x76, 0x03, 0xA0, 0x32, 0x03, 0xA0, 0x37, 0x58, 0x1D,
  0xF7, 0x48, 0x18, 0xFD, 0x60, 0xBF, 0xFE, 0x0B, 0x0D, 0xFF, 0xE0, 0xD0, 0x9F, 0xFE, 0x09, 0x05,
  0xFF, 0xE0, 0x50, 0x1F, 0x98, 0x2B, 0x11, 0xBF, 0x98, 0x11, 0x0C, 0xF0, 0x12, 0x01, 0xF0, 0xC2,
  0x08, 0xF0, 0x12, 0x01, 0xF0, 0x82, 0x03, 0xF8, 0x2B, 0x11, 0xBF, 0x04, 0x30, 0xEF, 0xFA, 0x0E,
  0x40, 0xAF, 0xFA, 0x0B, 0x40, 0x6F, 0xFA, 0x06, 0x50, 0xAF, 0xF0, 0xA3,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_shopping_basket() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_shopping_basket_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_shopping_cart_checkout 24x24, 4-bit Alpha,  RLE, 122 bytes.
static const unsigned char ic_round_24_action_shopping_cart_checkout_data[] PROGMEM = {
  0x0B, 0xA0, 0x66, 0x00, 0x57, 0x10, 0xBA, 0x0E, 0x68, 0x1D, 0xF7, 0x72, 0x81, 0xBF, 0x75, 0x05,
  0xA0, 0x74, 0x07, 0x02, 0x28, 0x14, 0xFD, 0x20, 0xBE, 0x05, 0x28, 0x18, 0xF8, 0x38, 0x3C, 0xF6,
  0x0B, 0xE8, 0x45, 0x01, 0xEF, 0x33, 0x81, 0x5F, 0xD4, 0x05, 0xA0, 0x72, 0x81, 0x9F, 0xA5, 0x81,
  0xDF, 0x53, 0x81, 0xDF, 0x72, 0x02, 0xA0, 0x25, 0x81, 0x6F, 0xC3, 0x00, 0x53, 0x81, 0xAF, 0x97,
  0x81, 0xDF, 0x46, 0x82, 0x3F, 0xE1, 0x70, 0x8F, 0xB0, 0x87, 0x10, 0xDF, 0xA0, 0xA7, 0x18, 0x17,
  0xFC, 0x77, 0x38, 0x1D, 0xF4, 0x77, 0x30, 0xDF, 0xD0, 0xB6, 0x04, 0x0D, 0xFC, 0x0B, 0x77, 0x75,
  0x82, 0x4D, 0xD4, 0x68, 0x24, 0xDD, 0x46, 0x0D, 0xA0, 0xD6, 0x0D, 0xA0, 0xD6, 0x0D, 0xA0, 0xD6,
  0x0D, 0xA0, 0xD6, 0x82, 0x4D, 0xD4, 0x68, 0x24, 0xDD, 0x42,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_shopping_cart_checkout() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_shopping_cart_checkout_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_shopping_cart 24x24, 4-bit Alpha,  RLE, 86 bytes.
static const unsigned char ic_round_24_action_shopping_cart_data[] PROGMEM = {
  0x0B, 0xA0, 0x67, 0x72, 0x0B, 0xA0, 0xE7, 0x74, 0x0B, 0xFF, 0xA0, 0xB2, 0x04, 0xFF, 0xA0, 0xC3,
  0x0C, 0xFF, 0x90, 0x43, 0x05, 0xFF, 0x0B, 0x50, 0xDF, 0xE0, 0x35, 0x06, 0xFD, 0x0A, 0x70, 0xDF,
  0xC0, 0x27, 0x08, 0xFB, 0x08, 0x71, 0x0D, 0xFA, 0x0A, 0x71, 0x81, 0x7F, 0xC7, 0x73, 0x81, 0xDF,
  0x47, 0x73, 0x0D, 0xFD, 0x0B, 0x60, 0x40, 0xDF, 0xC0, 0xB7, 0x77, 0x58, 0x24, 0xDD, 0x46, 0x82,
  0x4D, 0xD4, 0x60, 0xDA, 0x0D, 0x60, 0xDA, 0x0D, 0x60, 0xDA, 0x0D, 0x60, 0xDA, 0x0D, 0x68, 0x24,
  0xDD, 0x46, 0x82, 0x4D, 0xD4, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_shopping_cart() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_shopping_cart_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_shop 24x24, 4-bit Alpha,  RLE, 65 bytes.
static const unsigned char ic_round_24_action_shop_data[] PROGMEM = {
  0x60, 0x40, 0xDC, 0x0D, 0x04, 0x75, 0x0D, 0xE0, 0xD7, 0x5A, 0x4A, 0x75, 0xA4, 0xA6, 0x04, 0x0D,
  0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDF, 0xFF, 0xE0, 0x70, 0xCF, 0xFC, 0x20, 0x50, 0xDF, 0xFA,
  0x40, 0x60, 0xDF, 0xF6, 0x07, 0xFE, 0x60, 0x5F, 0xE4, 0x01, 0x0A, 0xFF, 0x30, 0x50, 0xEF, 0xF9,
  0x10, 0x10, 0xAF, 0xFB, 0x08, 0x0E, 0xFF, 0xFF, 0xB0, 0xDF, 0xFC, 0x81, 0xD4, 0xDF, 0xFA, 0x0D,
  0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_shop() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_shop_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_shop_two 24x24, 4-bit Alpha,  RLE, 82 bytes.
static const unsigned char ic_round_24_action_shop_two_data[] PROGMEM = {
  0x72, 0x04, 0x0D, 0xC0, 0xD0, 0x47, 0x70, 0xDE, 0x0D, 0x77, 0xA4, 0xA7, 0x7A, 0x4A, 0x72, 0x04,
  0x0D, 0xFF, 0x0D, 0x04, 0x40, 0xDF, 0xFA, 0x0D, 0x4F, 0xFC, 0x4F, 0x07, 0x0C, 0xFA, 0x00, 0xB2,
  0xF2, 0x05, 0x0D, 0xFA, 0x2F, 0x40, 0x7F, 0x92, 0xF4, 0x04, 0xF9, 0x2F, 0x30, 0x8F, 0xA2, 0xF1,
  0x02, 0x0C, 0xFB, 0x2F, 0x09, 0x0E, 0xFC, 0x2F, 0xFE, 0x20, 0xDF, 0xFA, 0x0D, 0xA2, 0x04, 0x0D,
  0xFF, 0x0D, 0x04, 0xA7, 0x76, 0xA0, 0x37, 0x75, 0x0D, 0xFF, 0xA0, 0xD4, 0x04, 0x0D, 0xFF, 0x0D,
  0x04, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_shop_two() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 21), Box(0, 0, 23, 23),
      ic_round_24_action_shop_two_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_smart_button 24x24, 4-bit Alpha,  RLE, 58 bytes.
static const unsigned char ic_round_24_action_smart_button_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDA, 0x77, 0x2C, 0x75, 0x00, 0x22, 0xC7, 0x48,
  0x22, 0xCC, 0x21, 0xC7, 0x38, 0x32, 0x2C, 0xC2, 0x1C, 0x72, 0x02, 0x90, 0xF2, 0x2C, 0x71, 0x83,
  0x2B, 0xFB, 0x23, 0xA0, 0xDF, 0x10, 0x2D, 0x02, 0x1A, 0x81, 0xD4, 0xDE, 0x28, 0x32, 0xBF, 0xB2,
  0x29, 0x0D, 0x04, 0x74, 0x81, 0x2F, 0x27, 0x74, 0x02, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_smart_button() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 7, 21, 18), Box(0, 0, 23, 23),
      ic_round_24_action_smart_button_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_source 24x24, 4-bit Alpha,  RLE, 38 bytes.
static const unsigned char ic_round_24_action_source_data[] PROGMEM = {
  0x04, 0x0D, 0xD0, 0xE0, 0x67, 0x40, 0xDF, 0x90, 0x77, 0x3F, 0xFC, 0x0D, 0x04, 0xFF, 0xD0, 0xD8,
  0x0D, 0x0F, 0x75, 0xF9, 0x75, 0x80, 0xD4, 0xF7, 0x1F, 0xD7, 0x18, 0x0D, 0x4F, 0x0D, 0xFF, 0xC8,
  0x1D, 0x4D, 0xFF, 0xA0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_source() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_source_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_space_dashboard 24x24, 4-bit Alpha,  RLE, 70 bytes.
static const unsigned char ic_round_24_action_space_dashboard_data[] PROGMEM = {
  0x04, 0x0D, 0xC0, 0xD0, 0x42, 0x04, 0x0D, 0xC8, 0x1D, 0x4D, 0xE0, 0xD2, 0x0D, 0xE0, 0xDF, 0x92,
  0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0x0D, 0xE0, 0xDF, 0x92, 0x04, 0x0D, 0xC0, 0xD0, 0x4F, 0x97,
  0x3F, 0x97, 0x3F, 0x92, 0x04, 0x0D, 0xC0, 0xD0, 0x4F, 0x92, 0x0D, 0xE0, 0xDF, 0x92, 0xFF, 0xA2,
  0xFF, 0xA2, 0xFF, 0xA2, 0xFF, 0xA2, 0xF9, 0x0D, 0xE0, 0xD2, 0x0D, 0xE8, 0x1D, 0x4D, 0xC0, 0xD0,
  0x42, 0x04, 0x0D, 0xC0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_space_dashboard() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_space_dashboard_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_spatial_audio_off 24x24, 4-bit Alpha,  RLE, 117 bytes.
static const unsigned char ic_round_24_action_spatial_audio_off_data[] PROGMEM = {
  0x77, 0x30, 0x20, 0x77, 0x75, 0x81, 0x9F, 0x87, 0x74, 0x03, 0xA0, 0x27, 0x78, 0x52, 0x91, 0x0A,
  0xF7, 0x58, 0x41, 0xAD, 0xDA, 0x13, 0x85, 0x7F, 0x90, 0x4F, 0xC4, 0x01, 0x0E, 0xC0, 0xE0, 0x12,
  0x85, 0x2F, 0xD0, 0x1F, 0xE4, 0x0A, 0xE0, 0xA3, 0x90, 0xE2, 0x90, 0xE4, 0x0D, 0xE0, 0xD2, 0x85,
  0x4F, 0xC0, 0x1F, 0xD4, 0x0D, 0xE0, 0xD2, 0x85, 0x7F, 0x60, 0x5F, 0xA4, 0x0A, 0xE0, 0xA3, 0x05,
  0x28, 0x1B, 0xF5, 0x40, 0x10, 0xEC, 0x0E, 0x01, 0x58, 0x15, 0xFD, 0x68, 0x41, 0xAD, 0xDA, 0x16,
  0x81, 0x8F, 0x57, 0x75, 0x03, 0x58, 0x23, 0x8B, 0xDA, 0x82, 0xDB, 0x83, 0x72, 0x05, 0x0C, 0xFB,
  0x0C, 0x05, 0x60, 0x6F, 0xF0, 0x65, 0x0D, 0xFF, 0x0D, 0x5F, 0xFA, 0x50, 0xDF, 0xF0, 0xD5, 0x04,
  0x0D, 0xFD, 0x0D, 0x04, 0x50,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_spatial_audio_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 1, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_spatial_audio_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_spatial_audio 24x24, 4-bit Alpha,  RLE, 105 bytes.
static const unsigned char ic_round_24_action_spatial_audio_data[] PROGMEM = {
  0x75, 0x00, 0xB2, 0x0A, 0x0C, 0x77, 0x18, 0x5D, 0xF2, 0x0B, 0xF6, 0x77, 0x83, 0x9F, 0x60, 0x4A,
  0x06, 0x76, 0x81, 0x4F, 0xD2, 0x07, 0xA0, 0xC5, 0x84, 0x1A, 0xDD, 0xA1, 0x28, 0x1B, 0xF9, 0x28,
  0x14, 0xB9, 0x40, 0x10, 0xEC, 0x85, 0xE1, 0x02, 0xEF, 0xA7, 0x10, 0xAE, 0x0A, 0x28, 0x43, 0xEF,
  0xE7, 0x35, 0x0D, 0xE0, 0xD3, 0x02, 0x0C, 0xB0, 0xB4, 0x0D, 0xE0, 0xD5, 0x82, 0x49, 0xCA, 0x40,
  0xAE, 0x0A, 0x76, 0x01, 0x0E, 0xC0, 0xE0, 0x17, 0x78, 0x41, 0xAD, 0xDA, 0x17, 0x77, 0x76, 0x82,
  0x38, 0xBD, 0xA8, 0x2D, 0xB8, 0x37, 0x20, 0x50, 0xCF, 0xB0, 0xC0, 0x56, 0x06, 0xFF, 0x06, 0x50,
  0xDF, 0xF0, 0xD5, 0xFF, 0xA5, 0xFF, 0xA5, 0xFF, 0xA5,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_spatial_audio() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 1, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_spatial_audio_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_spatial_tracking 24x24, 4-bit Alpha,  RLE, 112 bytes.
static const unsigned char ic_round_24_action_spatial_tracking_data[] PROGMEM = {
  0x77, 0x20, 0x70, 0x27, 0x74, 0x81, 0x8F, 0x97, 0x73, 0x01, 0xA0, 0x37, 0x73, 0x85, 0x7F, 0x90,
  0x19, 0x25, 0x84, 0x1A, 0xDD, 0xA1, 0x38, 0x5B, 0xF3, 0x08, 0xF7, 0x40, 0x10, 0xEC, 0x0E, 0x01,
  0x20, 0xE9, 0x28, 0x1D, 0xF2, 0x40, 0xAE, 0x0A, 0x2A, 0x20, 0xE9, 0x50, 0xDE, 0x0D, 0x28, 0x5E,
  0xF1, 0x0C, 0xF3, 0x40, 0xDE, 0x0D, 0x28, 0x5B, 0xF5, 0x07, 0xF7, 0x40, 0xAE, 0x0A, 0x28, 0x16,
  0xFC, 0x20, 0x55, 0x01, 0x0E, 0xC0, 0xE0, 0x12, 0x82, 0x1E, 0xF5, 0x71, 0x84, 0x1A, 0xDD, 0xA1,
  0x48, 0x15, 0xF8, 0x77, 0x50, 0x37, 0x82, 0x38, 0xBD, 0xA8, 0x2D, 0xB8, 0x37, 0x20, 0x50, 0xCF,
  0xB0, 0xC0, 0x56, 0x06, 0xFF, 0x06, 0x50, 0xDF, 0xF0, 0xD5, 0xFF, 0xA5, 0xFF, 0xA5, 0xFF, 0xA5,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_spatial_tracking() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 1, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_spatial_tracking_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_speaker_notes_off 24x24, 4-bit Alpha,  RLE, 126 bytes.
static const unsigned char ic_round_24_action_speaker_notes_off_data[] PROGMEM = {
  0x83, 0x5C, 0x20, 0x6F, 0xF9, 0x86, 0xD4, 0x5F, 0xD2, 0x06, 0xFF, 0x98, 0x6D, 0x07, 0xFD, 0x20,
  0x6F, 0xF9, 0x2A, 0x82, 0xD2, 0x06, 0xFF, 0x2B, 0x84, 0xD2, 0x06, 0xF3, 0x60, 0x3C, 0x2C, 0x83,
  0xD2, 0x06, 0x36, 0x03, 0xC2, 0xD8, 0x2D, 0x20, 0x6F, 0xC2, 0xC8, 0x23, 0x3D, 0x27, 0x03, 0xC2,
  0xC8, 0x33, 0x3F, 0xD2, 0x60, 0x3C, 0x2F, 0x98, 0x2D, 0x20, 0x6F, 0x92, 0xC0, 0x03, 0xB8, 0x2D,
  0x20, 0x6F, 0x2C, 0x00, 0x3C, 0x82, 0xD2, 0x06, 0xE2, 0xFC, 0x82, 0xD2, 0x06, 0xD2, 0xFD, 0x82,
  0xD2, 0x06, 0xC2, 0xFE, 0x82, 0xD2, 0x06, 0xA0, 0xD2, 0xFF, 0x84, 0xD2, 0x06, 0xD4, 0x2B, 0x07,
  0x72, 0x82, 0x7F, 0xD2, 0x5A, 0x07, 0x74, 0x82, 0x7F, 0xD2, 0x49, 0x07, 0x76, 0x82, 0x7F, 0xD2,
  0x30, 0x77, 0x71, 0x82, 0x7F, 0xD2, 0x77, 0x58, 0x17, 0xF8, 0x77, 0x60, 0x30, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_speaker_notes_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 2, 21, 23), Box(0, 0, 23, 23),
      ic_round_24_action_speaker_notes_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_speaker_notes 24x24, 4-bit Alpha,  RLE, 58 bytes.
static const unsigned char ic_round_24_action_speaker_notes_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xD8, 0x0D, 0x0F, 0x2A, 0x03, 0x60, 0x3F, 0x92,
  0xA0, 0x36, 0x03, 0xFF, 0xFF, 0x2A, 0x03, 0x60, 0x3F, 0x92, 0xA0, 0x36, 0x03, 0xFF, 0xFF, 0x2A,
  0x03, 0x30, 0x3F, 0xC2, 0xA0, 0x33, 0x03, 0x80, 0xF6, 0xF0, 0xDF, 0xFC, 0x0D, 0x04, 0xB0, 0x77,
  0x72, 0xA0, 0x77, 0x73, 0x90, 0x77, 0x74, 0x07, 0x77, 0x50,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_speaker_notes() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_speaker_notes_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_spellcheck 24x24, 4-bit Alpha,  RLE, 105 bytes.
static const unsigned char ic_round_24_action_spellcheck_data[] PROGMEM = {
  0x48, 0x16, 0xE6, 0x77, 0x38, 0x1E, 0xFE, 0x77, 0x28, 0x36, 0xFD, 0xF6, 0x77, 0x18, 0x3C, 0xF3,
  0xFC, 0x77, 0x85, 0x3F, 0xB0, 0xBF, 0x37, 0x68, 0x59, 0xF5, 0x05, 0xF9, 0x76, 0x00, 0xE3, 0x00,
  0xE7, 0x58, 0x15, 0xF9, 0x38, 0x19, 0xF5, 0x74, 0x0B, 0xF0, 0xB7, 0x30, 0x2F, 0xA0, 0x26, 0x84,
  0x5D, 0x58, 0xF7, 0x58, 0x17, 0xF8, 0x50, 0x5A, 0x82, 0x5E, 0xF1, 0x58, 0x11, 0xFE, 0x40, 0x5A,
  0x82, 0x70, 0xD9, 0x70, 0x90, 0xD3, 0x05, 0xA0, 0x77, 0x10, 0x60, 0x35, 0x05, 0xA0, 0x77, 0x10,
  0x1A, 0x05, 0x30, 0x5A, 0x07, 0x73, 0x07, 0xA8, 0x15, 0x05, 0xA0, 0x77, 0x50, 0x7A, 0x08, 0xA0,
  0x77, 0x70, 0x7B, 0x07, 0x77, 0x28, 0x17, 0xF7, 0x71,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_spellcheck() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 22, 21), Box(0, 0, 23, 23),
      ic_round_24_action_spellcheck_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_star_rate 24x24, 4-bit Alpha,  RLE, 67 bytes.
static const unsigned char ic_round_24_action_star_rate_data[] PROGMEM = {
  0x70, 0x04, 0x76, 0x01, 0xA0, 0x17, 0x50, 0x5A, 0x05, 0x75, 0x0A, 0xA0, 0xA7, 0x50, 0xEA, 0x0E,
  0x74, 0x04, 0xC0, 0x45, 0x09, 0xFF, 0x00, 0x9F, 0xF8, 0x1A, 0x07, 0xFD, 0x07, 0x30, 0x30, 0xDF,
  0x90, 0xD0, 0x36, 0x0E, 0xE0, 0xE7, 0x02, 0xF9, 0x02, 0x60, 0x7F, 0x90, 0x76, 0x0C, 0xB0, 0x0A,
  0xB0, 0xB5, 0x01, 0xB0, 0x62, 0x07, 0xB0, 0x14, 0x82, 0x3F, 0xD3, 0x48, 0x23, 0xDF, 0x35, 0x03,
  0x70, 0x10, 0x33,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_star_rate() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 4, 19, 20), Box(0, 0, 23, 23),
      ic_round_24_action_star_rate_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_stars 24x24, 4-bit Alpha,  RLE, 122 bytes.
static const unsigned char ic_round_24_action_stars_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x50, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8E, 0x00, 0xEE, 0x08, 0x30, 0x4F, 0x00, 0x5F, 0x04, 0x20, 0xDE, 0x0E, 0x20, 0xEE, 0x81, 0xD0,
  0x5F, 0x08, 0x20, 0x8F, 0x05, 0x0A, 0xB8, 0x3D, 0xBA, 0x91, 0x28, 0x31, 0x9A, 0xBD, 0xB0, 0x90,
  0xDB, 0x75, 0x0E, 0xA0, 0xD0, 0xEB, 0x0C, 0x01, 0x71, 0x01, 0x0C, 0xB0, 0x0E, 0xC0, 0xD0, 0x26,
  0x03, 0x0D, 0xC0, 0xE0, 0xDD, 0x0C, 0x60, 0xCD, 0x0D, 0x0A, 0xD0, 0x86, 0x09, 0xD0, 0x90, 0x5D,
  0x05, 0x20, 0x03, 0x20, 0x5D, 0x81, 0x50, 0xDC, 0x81, 0x11, 0x9A, 0x81, 0x91, 0x1C, 0x0D, 0x20,
  0x4C, 0x0A, 0x0E, 0xC0, 0xE0, 0xAC, 0x04, 0x30, 0x8F, 0xF0, 0x85, 0x08, 0xFD, 0x08, 0x70, 0x50,
  0xDF, 0x90, 0xD0, 0x47, 0x38, 0x65, 0x9D, 0xEE, 0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_stars() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_stars_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_sticky_note_2 24x24, 4-bit Alpha,  RLE, 60 bytes.
static const unsigned char ic_round_24_action_sticky_note_2_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xE6, 0xF0, 0x37, 0x10, 0x3F, 0x90, 0x37,
  0x10, 0x38, 0x0D, 0x0F, 0x03, 0x30, 0x3F, 0xE0, 0x33, 0x03, 0xFF, 0xE0, 0x33, 0x01, 0x0D, 0xFD,
  0x38, 0x21, 0xDF, 0x7F, 0xC2, 0x82, 0x1D, 0xF7, 0x1F, 0xC1, 0x82, 0x1D, 0xF7, 0x2F, 0xC8, 0x21,
  0xDF, 0x73, 0x0D, 0xFB, 0x81, 0xDF, 0x74, 0x04, 0x0D, 0xFB, 0x07, 0x50,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_sticky_note_2() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_sticky_note_2_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_store 24x24, 4-bit Alpha,  RLE, 57 bytes.
static const unsigned char ic_round_24_action_store_data[] PROGMEM = {
  0x20, 0xBF, 0xF0, 0xB4, 0x0B, 0xFF, 0x0B, 0x77, 0x73, 0x0D, 0xFF, 0x0D, 0x30, 0x4F, 0xFA, 0x04,
  0x20, 0x7F, 0xFA, 0x07, 0x20, 0xAF, 0xFA, 0x0A, 0x20, 0xDF, 0xFA, 0x81, 0xD0, 0x1F, 0xFC, 0x81,
  0x10, 0xDF, 0xFA, 0x0D, 0x3A, 0x6A, 0x4A, 0x4A, 0x6A, 0x4A, 0x4A, 0x6A, 0x4A, 0x4A, 0x6A, 0x4A,
  0x4F, 0xB4, 0xA4, 0x0B, 0xF9, 0x0B, 0x40, 0x0B, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_store() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_store_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_subject 24x24, 4-bit Alpha,  RLE, 31 bytes.
static const unsigned char ic_round_24_action_subject_data[] PROGMEM = {
  0x0B, 0xFF, 0x00, 0xBF, 0xF0, 0xB7, 0x77, 0x74, 0x0B, 0xFF, 0x00, 0xBF, 0xF0, 0xB7, 0x77, 0x74,
  0x0B, 0xFF, 0x00, 0xBF, 0xF0, 0xB7, 0x77, 0x74, 0x0B, 0xF9, 0x0B, 0x60, 0xBF, 0x90, 0xB6,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_subject() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 5, 19, 18), Box(0, 0, 23, 23),
      ic_round_24_action_subject_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_subtitles_off 24x24, 4-bit Alpha,  RLE, 104 bytes.
static const unsigned char ic_round_24_action_subtitles_off_data[] PROGMEM = {
  0x81, 0x5F, 0x77, 0x74, 0x03, 0xA0, 0x72, 0x0A, 0xFD, 0x82, 0xD4, 0x0D, 0xA0, 0x72, 0x0A, 0xFD,
  0x0D, 0x1C, 0x07, 0x20, 0xAF, 0xD1, 0xD0, 0x72, 0x0A, 0xFC, 0x1E, 0x07, 0x20, 0xAF, 0xB1, 0xF0,
  0x72, 0x0A, 0xFA, 0x1F, 0x90, 0x72, 0x0A, 0xF9, 0x1F, 0xA0, 0x72, 0x0A, 0xF1, 0xA0, 0x32, 0x03,
  0xC0, 0x76, 0x03, 0xA1, 0xA0, 0x32, 0x03, 0xD0, 0x75, 0x03, 0xA1, 0xFD, 0x07, 0x20, 0xAC, 0x1F,
  0xE0, 0x72, 0x0A, 0xB1, 0xA0, 0x37, 0x10, 0x5A, 0x07, 0x20, 0xAA, 0x1A, 0x03, 0x71, 0x03, 0xB0,
  0x72, 0x82, 0xAF, 0x0D, 0xFF, 0x90, 0x72, 0x82, 0x80, 0x4D, 0xFF, 0x90, 0x77, 0x74, 0x05, 0xA0,
  0x77, 0x74, 0x05, 0xA7, 0x75, 0x03, 0x05, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_subtitles_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_subtitles_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_supervised_user_circle 24x24, 4-bit Alpha,  RLE, 146 bytes.
static const unsigned char ic_round_24_action_supervised_user_circle_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xC8, 0x1E, 0xCE, 0xFA, 0x04, 0x20, 0xDB, 0x0D, 0x01, 0x20, 0xBF, 0x98,
  0x1D, 0x05, 0xC0, 0x53, 0x02, 0xA8, 0x1B, 0x69, 0xC0, 0x50, 0x9C, 0x05, 0x38, 0x11, 0xFD, 0x30,
  0xAB, 0x09, 0x0D, 0xC0, 0xB3, 0x81, 0x8F, 0xB3, 0x08, 0xB0, 0xD0, 0xED, 0x81, 0xC8, 0xBB, 0x82,
  0x30, 0x1D, 0xB0, 0x0E, 0xFD, 0x0D, 0x0E, 0xC0, 0xE0, 0xDA, 0x85, 0xE8, 0x41, 0x02, 0xDA, 0x81,
  0xDB, 0xDC, 0x83, 0xD9, 0xFB, 0x14, 0x82, 0xDE, 0x71, 0x48, 0x56, 0xDF, 0x95, 0xFD, 0x48, 0x15,
  0xF6, 0x78, 0x5D, 0xF5, 0x0D, 0xF6, 0x38, 0x16, 0xF3, 0x68, 0x17, 0xFD, 0x20, 0x4A, 0x04, 0x28,
  0x16, 0xF3, 0x50, 0x5A, 0x04, 0x30, 0x8A, 0x83, 0x60, 0x6F, 0x34, 0x06, 0xA0, 0x85, 0x08, 0xA8,
  0x6D, 0xAF, 0x31, 0x37, 0xDA, 0x08, 0x70, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x38, 0x65, 0x9D, 0xEE,
  0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_supervised_user_circle() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_supervised_user_circle_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_supervisor_account 24x24, 4-bit Alpha,  RLE, 74 bytes.
static const unsigned char ic_round_24_action_supervisor_account_data[] PROGMEM = {
  0x58, 0x28, 0xDD, 0x87, 0x71, 0x08, 0xC0, 0x87, 0x70, 0xDC, 0x0D, 0x28, 0x31, 0xBE, 0xB1, 0x70,
  0xDC, 0x0D, 0x20, 0xBB, 0x0B, 0x70, 0x8C, 0x08, 0x20, 0xEB, 0x0E, 0x71, 0x82, 0x8D, 0xD8, 0x30,
  0xBB, 0x0B, 0x77, 0x18, 0x31, 0xBE, 0xB1, 0x77, 0x74, 0x85, 0x15, 0xAD, 0xEF, 0xB7, 0x50, 0x8D,
  0x0D, 0x28, 0x91, 0x16, 0xBD, 0xFE, 0xB6, 0x10, 0x9E, 0x82, 0x40, 0x4E, 0xF0, 0xE0, 0x4F, 0x20,
  0xEF, 0xA0, 0xEF, 0x2F, 0xC0, 0xBE, 0x20, 0xBF, 0xA0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_supervisor_account() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 5, 21, 18), Box(0, 0, 23, 23),
      ic_round_24_action_supervisor_account_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_support 24x24, 4-bit Alpha,  RLE, 162 bytes.
static const unsigned char ic_round_24_action_support_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xA0, 0x0D, 0xC0,
  0xE0, 0xDA, 0x08, 0x50, 0x8A, 0x81, 0x60, 0x7C, 0x81, 0x70, 0x6A, 0x08, 0x30, 0x4A, 0x04, 0x20,
  0x10, 0xEB, 0x01, 0x20, 0x4A, 0x04, 0x28, 0x1D, 0xF6, 0x30, 0x40, 0xDA, 0x0E, 0x04, 0x38, 0x56,
  0xFD, 0x05, 0xFD, 0x30, 0x7E, 0x07, 0x38, 0x7D, 0xF5, 0x9F, 0xD7, 0x14, 0xA8, 0x27, 0x11, 0x7A,
  0x85, 0x41, 0x7E, 0xF9, 0xDC, 0x81, 0xEF, 0x74, 0x81, 0x7F, 0xEC, 0x0D, 0x0E, 0xE0, 0x14, 0x01,
  0xE0, 0x0E, 0xE0, 0x14, 0x01, 0xE0, 0xE0, 0xDC, 0x81, 0xEF, 0x74, 0x81, 0x7F, 0xEC, 0x85, 0xD9,
  0xFD, 0x71, 0x4A, 0x82, 0x71, 0x17, 0xA8, 0x74, 0x17, 0xEF, 0x95, 0xFD, 0x30, 0x7E, 0x07, 0x38,
  0x5D, 0xF5, 0x0D, 0xF6, 0x30, 0x40, 0xEA, 0x0E, 0x04, 0x38, 0x16, 0xFD, 0x20, 0x4A, 0x04, 0x20,
  0x1C, 0x01, 0x20, 0x4A, 0x04, 0x30, 0x8A, 0x81, 0x60, 0x7C, 0x81, 0x70, 0x6A, 0x08, 0x50, 0x8A,
  0x00, 0xDC, 0x0E, 0x0D, 0xA0, 0x87, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED,
  0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_support() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_support_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swap_horizontal_circle 24x24, 4-bit Alpha,  RLE, 114 bytes.
static const unsigned char ic_round_24_action_swap_horizontal_circle_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFC, 0x0D, 0xC0, 0x42, 0x0D, 0xFC, 0x01, 0x0D, 0xB8, 0x1D, 0x05, 0xFD,
  0x10, 0x10, 0xDB, 0x05, 0x09, 0xF9, 0x60, 0x10, 0xEA, 0x09, 0x0D, 0xD0, 0xDA, 0x60, 0x10, 0xEA,
  0x0D, 0x0E, 0xC0, 0xD0, 0x1E, 0x10, 0x10, 0xDB, 0x00, 0xEB, 0x0D, 0x01, 0x1E, 0x01, 0x0D, 0xC0,
  0xE0, 0xDA, 0x0E, 0x01, 0x6A, 0x0D, 0xD0, 0xD0, 0x9A, 0x0E, 0x01, 0x6F, 0x90, 0x90, 0x5B, 0x0D,
  0x01, 0x1F, 0xD8, 0x15, 0x0D, 0xB0, 0xD0, 0x1F, 0xC0, 0xD2, 0x04, 0xC0, 0xDF, 0xC0, 0x43, 0x08,
  0xFF, 0x08, 0x50, 0x8F, 0xD0, 0x87, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED,
  0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swap_horizontal_circle() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_swap_horizontal_circle_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swap_horiz 24x24, 4-bit Alpha,  RLE, 45 bytes.
static const unsigned char ic_round_24_action_swap_horiz_data[] PROGMEM = {
  0x77, 0x02, 0x77, 0x39, 0x07, 0x77, 0x2A, 0x07, 0x71, 0x0B, 0xFA, 0x07, 0x70, 0xBF, 0xA0, 0x77,
  0x7A, 0x07, 0x40, 0x27, 0x39, 0x07, 0x40, 0x79, 0x73, 0x02, 0x40, 0x7A, 0x77, 0x07, 0xFA, 0x0B,
  0x70, 0x7F, 0xA0, 0xB7, 0x10, 0x7A, 0x77, 0x20, 0x79, 0x77, 0x30, 0x27, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swap_horiz() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 5, 20, 18), Box(0, 0, 23, 23),
      ic_round_24_action_swap_horiz_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swap_vertical_circle 24x24, 4-bit Alpha,  RLE, 112 bytes.
static const unsigned char ic_round_24_action_swap_vertical_circle_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8C, 0x00, 0xEF, 0x90, 0x83, 0x04, 0xC8, 0x2D, 0x11, 0xDF, 0x90, 0x42, 0x0D, 0xB0, 0xD0, 0x12,
  0x01, 0x0D, 0xF8, 0x1D, 0x05, 0xB0, 0xD0, 0x14, 0x01, 0x0D, 0xF0, 0x50, 0x9E, 0x2F, 0xB0, 0x90,
  0xDE, 0x2F, 0xB0, 0xD0, 0xEE, 0x2A, 0x2E, 0x00, 0xEE, 0x2A, 0x2E, 0x0E, 0x0D, 0xFB, 0x2E, 0x0D,
  0x09, 0xFB, 0x2E, 0x09, 0x05, 0xF0, 0xD0, 0x14, 0x01, 0x0D, 0xB8, 0x15, 0x0D, 0xF0, 0xD0, 0x12,
  0x01, 0x0D, 0xB0, 0xD2, 0x04, 0xF9, 0x82, 0xD1, 0x1D, 0xC0, 0x43, 0x08, 0xF9, 0x00, 0xEC, 0x08,
  0x50, 0x8F, 0xD0, 0x87, 0x04, 0x0D, 0xF9, 0x0D, 0x04, 0x73, 0x86, 0x59, 0xDE, 0xED, 0x95, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swap_vertical_circle() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_swap_vertical_circle_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swap_vert 24x24, 4-bit Alpha,  RLE, 45 bytes.
static const unsigned char ic_round_24_action_swap_vert_data[] PROGMEM = {
  0x30, 0x07, 0x74, 0x07, 0xA0, 0x77, 0x20, 0x7C, 0x07, 0x70, 0x2E, 0x02, 0x72, 0xA7, 0x5A, 0x75,
  0xA7, 0x5A, 0x40, 0x0B, 0x6A, 0x4A, 0x6A, 0x4A, 0x60, 0x0B, 0x4A, 0x75, 0xA7, 0x5A, 0x75, 0xA7,
  0x20, 0x2E, 0x02, 0x70, 0x7C, 0x07, 0x72, 0x07, 0xA0, 0x77, 0x40, 0x07, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swap_vert() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 18, 20), Box(0, 0, 23, 23),
      ic_round_24_action_swap_vert_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swipe_down_alt 24x24, 4-bit Alpha,  RLE, 55 bytes.
static const unsigned char ic_round_24_action_swipe_down_alt_data[] PROGMEM = {
  0x28, 0x44, 0xBE, 0xEB, 0x43, 0x08, 0xE8, 0x18, 0x04, 0xF9, 0x04, 0x0B, 0xF9, 0x0B, 0x0E, 0xF9,
  0x00, 0xEF, 0x90, 0xE0, 0xBF, 0x90, 0xB0, 0x3F, 0x98, 0x13, 0x07, 0xE0, 0x73, 0x04, 0x0A, 0xA0,
  0xA0, 0x46, 0xA7, 0x1A, 0x71, 0xA5, 0x81, 0x5D, 0x5A, 0x81, 0x5D, 0x52, 0x05, 0xE0, 0x53, 0x07,
  0xC0, 0x75, 0x07, 0xA0, 0x77, 0x00, 0x54,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swipe_down_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(7, 4, 16, 21), Box(0, 0, 23, 23),
      ic_round_24_action_swipe_down_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swipe_down 24x24, 4-bit Alpha,  RLE, 122 bytes.
static const unsigned char ic_round_24_action_swipe_down_data[] PROGMEM = {
  0x40, 0x20, 0x67, 0x77, 0x0D, 0x0C, 0x77, 0x68, 0x16, 0xF4, 0x77, 0x60, 0x0C, 0x38, 0x1B, 0xD3,
  0x77, 0x81, 0x1F, 0x72, 0x04, 0xA0, 0xB7, 0x78, 0x14, 0xF3, 0x20, 0x1B, 0x03, 0x76, 0x81, 0x6F,
  0x13, 0x09, 0xA0, 0xA7, 0x60, 0x79, 0x40, 0x2B, 0x01, 0x73, 0x84, 0x11, 0x6F, 0x11, 0x30, 0xBA,
  0x82, 0x80, 0x11, 0x78, 0x59, 0xE7, 0xF6, 0xE8, 0x20, 0x4A, 0x0E, 0x0C, 0xC8, 0x1D, 0xC5, 0x20,
  0x20, 0xDB, 0x0D, 0x01, 0x30, 0xDF, 0xB0, 0x12, 0x83, 0x2D, 0xFD, 0x14, 0x06, 0xFB, 0x05, 0x38,
  0x11, 0x71, 0x60, 0xEF, 0xA0, 0x97, 0x50, 0x7F, 0xA0, 0xE7, 0x50, 0x1F, 0xB0, 0x37, 0x18, 0x23,
  0x7A, 0xDF, 0xB0, 0x57, 0x02, 0xFE, 0x0E, 0x01, 0x71, 0x0A, 0xFB, 0x81, 0xE8, 0x17, 0x38, 0x11,
  0x7D, 0xD8, 0x1D, 0x71, 0x77, 0x18, 0x35, 0xBE, 0xB5, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swipe_down() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 23, 21), Box(0, 0, 23, 23),
      ic_round_24_action_swipe_down_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swipe_left_alt 24x24, 4-bit Alpha,  RLE, 54 bytes.
static const unsigned char ic_round_24_action_swipe_left_alt_data[] PROGMEM = {
  0x73, 0x84, 0x3B, 0xEE, 0xB4, 0x50, 0x05, 0x40, 0x7E, 0x08, 0x38, 0x17, 0xFD, 0x30, 0x4F, 0x98,
  0x14, 0x07, 0xA0, 0x53, 0x0A, 0xF9, 0x0B, 0x05, 0xFF, 0xA0, 0xE0, 0x5F, 0xFA, 0x81, 0xE0, 0x7A,
  0x05, 0x30, 0xAF, 0x90, 0xB2, 0x81, 0x7F, 0xD3, 0x04, 0xF9, 0x04, 0x30, 0x05, 0x40, 0x7E, 0x08,
  0x74, 0x84, 0x3B, 0xEE, 0xB4, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swipe_left_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 7, 19, 16), Box(0, 0, 23, 23),
      ic_round_24_action_swipe_left_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swipe_left 24x24, 4-bit Alpha,  RLE, 105 bytes.
static const unsigned char ic_round_24_action_swipe_left_data[] PROGMEM = {
  0x58, 0x90, 0x37, 0xBD, 0xEF, 0xDB, 0x83, 0x58, 0x3C, 0x50, 0x4C, 0xA8, 0x4C, 0x98, 0x79, 0xCA,
  0x0C, 0x03, 0x39, 0x84, 0x8A, 0xFD, 0x61, 0x78, 0x26, 0xDF, 0x82, 0xB0, 0x77, 0x58, 0x19, 0xF9,
  0x1A, 0x81, 0xB7, 0x53, 0x81, 0x8E, 0x86, 0x82, 0x8F, 0x4B, 0xB0, 0xC3, 0xB7, 0x0B, 0x08, 0x71,
  0xB7, 0x73, 0xB7, 0x73, 0xB7, 0x73, 0xB7, 0x73, 0xB7, 0x73, 0xB0, 0x70, 0x57, 0x71, 0xD0, 0xE0,
  0x67, 0x6F, 0x0E, 0x06, 0x74, 0xFA, 0x0A, 0x58, 0x23, 0x74, 0x11, 0xFA, 0x0E, 0x50, 0xBB, 0x0D,
  0xFA, 0x0D, 0x50, 0x30, 0xEF, 0xD0, 0xB6, 0x03, 0x0E, 0xFC, 0x09, 0x70, 0x4F, 0xC0, 0x77, 0x10,
  0x5F, 0xB0, 0x47, 0x20, 0x50, 0xDE, 0x0E, 0x09, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swipe_left() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 1, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_swipe_left_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swipe 24x24, 4-bit Alpha,  RLE, 99 bytes.
static const unsigned char ic_round_24_action_swipe_data[] PROGMEM = {
  0x58, 0x24, 0x8C, 0xDA, 0x82, 0xDC, 0x84, 0x50, 0x22, 0x89, 0x46, 0xDF, 0xEB, 0x98, 0x89, 0xBE,
  0xFD, 0x62, 0x85, 0x2F, 0x7A, 0xFB, 0x47, 0x18, 0x34, 0xBF, 0xA7, 0xC0, 0x67, 0x50, 0x6E, 0x07,
  0x48, 0x18, 0xE8, 0x50, 0x7B, 0x0E, 0xB0, 0x23, 0xB4, 0x02, 0xB0, 0xE7, 0x1B, 0x77, 0x3B, 0x77,
  0x3B, 0x77, 0x3B, 0x77, 0x3B, 0x77, 0x3B, 0x07, 0x04, 0x77, 0x1D, 0x0C, 0x05, 0x76, 0xF0, 0xD0,
  0x67, 0x4F, 0xA0, 0xA5, 0x82, 0x27, 0x41, 0x1F, 0xA0, 0xE5, 0x0B, 0xB0, 0xDF, 0xA0, 0xD5, 0x05,
  0xFE, 0x0B, 0x60, 0x5F, 0xD0, 0x97, 0x05, 0xFC, 0x07, 0x71, 0x05, 0xFB, 0x04, 0x72, 0x05, 0x0D,
  0xE0, 0xE0, 0x93,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swipe() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 1, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_swipe_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swipe_right_alt 24x24, 4-bit Alpha,  RLE, 54 bytes.
static const unsigned char ic_round_24_action_swipe_right_alt_data[] PROGMEM = {
  0x28, 0x44, 0xBE, 0xEB, 0x37, 0x40, 0x8E, 0x07, 0x40, 0x05, 0x30, 0x4F, 0x90, 0x43, 0x81, 0xDF,
  0x72, 0x0B, 0xF9, 0x0A, 0x30, 0x5A, 0x81, 0x70, 0xEF, 0xFA, 0x05, 0x0E, 0xFF, 0xA0, 0x50, 0xBF,
  0x90, 0xA3, 0x05, 0xA8, 0x17, 0x04, 0xF9, 0x04, 0x38, 0x1D, 0xF7, 0x30, 0x8E, 0x07, 0x40, 0x05,
  0x58, 0x44, 0xBE, 0xEB, 0x37, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swipe_right_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 7, 21, 16), Box(0, 0, 23, 23),
      ic_round_24_action_swipe_right_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swipe_right 24x24, 4-bit Alpha,  RLE, 105 bytes.
static const unsigned char ic_round_24_action_swipe_right_data[] PROGMEM = {
  0x58, 0x90, 0x38, 0xBD, 0xFE, 0xDB, 0x73, 0x71, 0x03, 0x0C, 0xA8, 0x4C, 0x97, 0x89, 0xCA, 0x83,
  0xC4, 0x05, 0xC2, 0x82, 0x8F, 0xD6, 0x78, 0x91, 0x16, 0xDF, 0xA8, 0xF0, 0x9F, 0x97, 0x50, 0x7B,
  0x81, 0x5F, 0x85, 0x81, 0x8E, 0x84, 0x81, 0x57, 0xBA, 0x08, 0x0B, 0x6B, 0x40, 0xCB, 0x0B, 0x71,
  0xB7, 0x73, 0xB7, 0x73, 0xB7, 0x73, 0xB7, 0x73, 0xB7, 0x73, 0xB0, 0x70, 0x57, 0x71, 0xD0, 0xE0,
  0x67, 0x6F, 0x0E, 0x06, 0x74, 0xFA, 0x0A, 0x58, 0x23, 0x74, 0x11, 0xFA, 0x0E, 0x50, 0xBB, 0x0D,
  0xFA, 0x0D, 0x50, 0x30, 0xEF, 0xD0, 0xB6, 0x03, 0x0E, 0xFC, 0x09, 0x70, 0x4F, 0xC0, 0x77, 0x10,
  0x5F, 0xB0, 0x47, 0x20, 0x50, 0xDE, 0x0E, 0x09, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swipe_right() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 1, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_swipe_right_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swipe_up_alt 24x24, 4-bit Alpha,  RLE, 67 bytes.
static const unsigned char ic_round_24_action_swipe_up_alt_data[] PROGMEM = {
  0x38, 0x21, 0xBB, 0x15, 0x01, 0x0C, 0xA0, 0xC0, 0x13, 0x01, 0x0C, 0xC0, 0xC0, 0x12, 0x81, 0x7F,
  0xCA, 0x81, 0xCF, 0x72, 0x81, 0x17, 0x1A, 0x81, 0x17, 0x15, 0xA7, 0x1A, 0x70, 0x1A, 0x01, 0x40,
  0x10, 0xAC, 0x0A, 0x01, 0x20, 0xCE, 0x81, 0xC0, 0x7F, 0x90, 0x70, 0xCF, 0x90, 0xC0, 0xEF, 0x90,
  0xE0, 0xDF, 0x90, 0xD0, 0x9F, 0x98, 0x19, 0x1E, 0xE8, 0x3E, 0x10, 0x2D, 0xC0, 0xD0, 0x24, 0x82,
  0x58, 0x85, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swipe_up_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(7, 2, 16, 19), Box(0, 0, 23, 23),
      ic_round_24_action_swipe_up_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swipe_up 24x24, 4-bit Alpha,  RLE, 123 bytes.
static const unsigned char ic_round_24_action_swipe_up_data[] PROGMEM = {
  0x28, 0x11, 0x71, 0x77, 0x58, 0x31, 0xDF, 0xD1, 0x77, 0x30, 0x10, 0xDB, 0x0D, 0x02, 0x77, 0x28,
  0x59, 0xE7, 0xF6, 0xE9, 0x77, 0x38, 0x31, 0x6F, 0x11, 0x28, 0x1B, 0xD3, 0x77, 0x07, 0x93, 0x04,
  0xA0, 0xB7, 0x78, 0x16, 0xF1, 0x20, 0x1B, 0x03, 0x76, 0x81, 0x4F, 0x33, 0x09, 0xA0, 0xA7, 0x68,
  0x11, 0xF7, 0x30, 0x2B, 0x01, 0x76, 0x00, 0xC4, 0x0B, 0xA8, 0x28, 0x01, 0x17, 0x38, 0x16, 0xF4,
  0x30, 0x4A, 0x0E, 0x0C, 0xC8, 0x1D, 0xC5, 0x60, 0xD0, 0xC4, 0x0D, 0xFB, 0x01, 0x50, 0x20, 0x64,
  0x06, 0xFB, 0x05, 0x75, 0x0E, 0xFA, 0x09, 0x75, 0x07, 0xFA, 0x0E, 0x75, 0x01, 0xFB, 0x03, 0x71,
  0x82, 0x37, 0xAD, 0xFB, 0x05, 0x70, 0x2F, 0xE0, 0xE0, 0x17, 0x10, 0xAF, 0xB8, 0x1E, 0x81, 0x73,
  0x81, 0x17, 0xDD, 0x81, 0xD7, 0x17, 0x71, 0x83, 0x5B, 0xEB, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swipe_up() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 23, 21), Box(0, 0, 23, 23),
      ic_round_24_action_swipe_up_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_swipe_vertical 24x24, 4-bit Alpha,  RLE, 138 bytes.
static const unsigned char ic_round_24_action_swipe_vertical_data[] PROGMEM = {
  0x10, 0xCB, 0x0B, 0x77, 0x50, 0x50, 0x8B, 0x77, 0x68, 0x1A, 0xFB, 0x97, 0x75, 0x82, 0x4F, 0x77,
  0x93, 0x81, 0xBD, 0x37, 0x68, 0x3C, 0xD0, 0x5C, 0x20, 0x4A, 0x0B, 0x75, 0x81, 0x3F, 0x65, 0x01,
  0xB0, 0x37, 0x48, 0x17, 0xF1, 0x60, 0x9A, 0x0A, 0x74, 0x0B, 0x0C, 0x70, 0x2B, 0x01, 0x73, 0x0D,
  0x09, 0x71, 0x0B, 0xA8, 0x28, 0x01, 0x17, 0x0E, 0x08, 0x71, 0x04, 0xA0, 0xE0, 0xCC, 0x81, 0xDC,
  0x52, 0x0E, 0x08, 0x72, 0x0D, 0xFB, 0x82, 0x10, 0xD9, 0x72, 0x06, 0xFB, 0x82, 0x50, 0xBC, 0x73,
  0x0E, 0xFA, 0x83, 0x90, 0x7F, 0x17, 0x20, 0x7F, 0xA8, 0x3E, 0x03, 0xF6, 0x72, 0x01, 0xFB, 0x85,
  0x30, 0xCD, 0x05, 0xC3, 0x82, 0x37, 0xAD, 0xFB, 0x84, 0x50, 0x4F, 0x77, 0x92, 0x02, 0xFE, 0x0E,
  0x01, 0x28, 0x1A, 0xFB, 0x93, 0x0A, 0xFB, 0x81, 0xE8, 0x12, 0x05, 0x08, 0xB4, 0x81, 0x17, 0xDD,
  0x81, 0xD7, 0x14, 0x0C, 0xB0, 0xB7, 0x83, 0x5B, 0xEB, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_swipe_vertical() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 2, 23, 21), Box(0, 0, 23, 23),
      ic_round_24_action_swipe_vertical_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_switch_access_shortcut_add 24x24, 4-bit Alpha,  RLE, 126 bytes.
static const unsigned char ic_round_24_action_switch_access_shortcut_add_data[] PROGMEM = {
  0x72, 0x02, 0xD0, 0xE7, 0x71, 0x07, 0xD7, 0x72, 0x08, 0xC7, 0x20, 0x03, 0x50, 0xBC, 0x72, 0x00,
  0xA4, 0x82, 0x7F, 0xD8, 0xA7, 0x03, 0x0A, 0xA0, 0xA0, 0x32, 0x83, 0xEF, 0x40, 0x79, 0x70, 0x30,
  0xAA, 0x84, 0xA3, 0x05, 0xFC, 0x30, 0x27, 0x20, 0x0A, 0x38, 0x1A, 0xF6, 0x76, 0x00, 0x33, 0x81,
  0xDF, 0x27, 0x30, 0x03, 0x60, 0xE9, 0x73, 0x82, 0x3C, 0xC3, 0x58, 0x1E, 0xF1, 0x50, 0x0B, 0x28,
  0x23, 0xCC, 0x35, 0x81, 0xCF, 0x35, 0xA3, 0x00, 0x36, 0x81, 0x9F, 0x63, 0x0B, 0xC0, 0xB4, 0x00,
  0x33, 0x81, 0x4F, 0xD3, 0x0B, 0xC0, 0xB4, 0x00, 0xA4, 0x81, 0xDF, 0x64, 0xA4, 0x03, 0x0A, 0xA0,
  0xA0, 0x32, 0x82, 0x5F, 0xE3, 0x30, 0x0B, 0x40, 0x30, 0xAA, 0x0A, 0x03, 0x38, 0x28, 0xFD, 0x37,
  0x30, 0x0A, 0x60, 0xBA, 0x06, 0x72, 0x00, 0x37, 0x81, 0x7F, 0xE7, 0x75, 0x00, 0x35,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_switch_access_shortcut_add() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 23, 21), Box(0, 0, 23, 23),
      ic_round_24_action_switch_access_shortcut_add_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_switch_access_shortcut 24x24, 4-bit Alpha,  RLE, 110 bytes.
static const unsigned char ic_round_24_action_switch_access_shortcut_data[] PROGMEM = {
  0x72, 0x02, 0xD0, 0xE7, 0x30, 0x7D, 0x74, 0x08, 0xC4, 0x00, 0x35, 0x0B, 0xC4, 0x00, 0xA4, 0x82,
  0x7F, 0xD8, 0xA2, 0x03, 0x0A, 0xA0, 0xA0, 0x32, 0x83, 0xEF, 0x40, 0x79, 0x20, 0x30, 0xAA, 0x84,
  0xA3, 0x05, 0xFC, 0x30, 0x24, 0x00, 0xA3, 0x81, 0xAF, 0x67, 0x10, 0x03, 0x38, 0x1D, 0xF2, 0x50,
  0x03, 0x60, 0xE9, 0x58, 0x23, 0xCC, 0x35, 0x81, 0xEF, 0x14, 0x82, 0x3C, 0xC3, 0x58, 0x1C, 0xF3,
  0x50, 0x03, 0x68, 0x19, 0xF6, 0x71, 0x00, 0x33, 0x81, 0x4F, 0xD7, 0x10, 0x0A, 0x48, 0x1D, 0xF6,
  0x50, 0x30, 0xAA, 0x0A, 0x03, 0x28, 0x25, 0xFE, 0x34, 0x03, 0x0A, 0xA0, 0xA0, 0x33, 0x82, 0x8F,
  0xD3, 0x50, 0x0A, 0x60, 0xBA, 0x06, 0x40, 0x03, 0x78, 0x17, 0xFE, 0x77, 0x00, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_switch_access_shortcut() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 18, 21), Box(0, 0, 23, 23),
      ic_round_24_action_switch_access_shortcut_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_sync_alt 24x24, 4-bit Alpha,  RLE, 51 bytes.
static const unsigned char ic_round_24_action_sync_alt_data[] PROGMEM = {
  0x77, 0x20, 0x27, 0x75, 0x90, 0x77, 0x74, 0xA0, 0x72, 0x0B, 0xFF, 0xB8, 0x17, 0x0B, 0xFF, 0xB0,
  0x77, 0x72, 0xA0, 0x77, 0x73, 0x90, 0x77, 0x74, 0x02, 0x60, 0x27, 0x74, 0x07, 0x97, 0x73, 0x07,
  0xA7, 0x72, 0x07, 0xFF, 0xB8, 0x1B, 0x07, 0xFF, 0xB0, 0xB2, 0x07, 0xA7, 0x74, 0x07, 0x97, 0x75,
  0x02, 0x77, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_sync_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_sync_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_system_update_alt 24x24, 4-bit Alpha,  RLE, 71 bytes.
static const unsigned char ic_round_24_action_system_update_alt_data[] PROGMEM = {
  0x04, 0x0D, 0xD0, 0xB2, 0x00, 0xB2, 0x0B, 0xD8, 0x1D, 0x4D, 0xE0, 0xB2, 0xA2, 0x0B, 0xE0, 0xDA,
  0x03, 0x7A, 0x70, 0x3C, 0x71, 0xA7, 0x1C, 0x71, 0xA7, 0x1C, 0x71, 0xA7, 0x1C, 0x71, 0xA7, 0x1C,
  0x71, 0xA7, 0x1C, 0x71, 0xA7, 0x1C, 0x50, 0x2E, 0x02, 0x5C, 0x60, 0x7C, 0x07, 0x6C, 0x70, 0x7A,
  0x07, 0x7C, 0x71, 0x00, 0x77, 0x1C, 0x77, 0x4C, 0x77, 0x4C, 0x03, 0x77, 0x20, 0x3A, 0x0D, 0xFF,
  0xE8, 0x1D, 0x4D, 0xFF, 0xC0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_system_update_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_system_update_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_table_view 24x24, 4-bit Alpha,  RLE, 69 bytes.
static const unsigned char ic_round_24_action_table_view_data[] PROGMEM = {
  0x04, 0x0D, 0xFB, 0x0D, 0x04, 0x40, 0xDF, 0xD0, 0xD4, 0xA7, 0x3A, 0x4A, 0x77, 0x2A, 0x20, 0x40,
  0xDF, 0xB0, 0xD0, 0x4A, 0x20, 0xDF, 0xD0, 0xDA, 0x2A, 0x03, 0x71, 0x03, 0xC2, 0xA0, 0x37, 0x10,
  0x3C, 0x2F, 0xFA, 0x2F, 0xFA, 0x2A, 0x2A, 0x2A, 0x2C, 0x2A, 0x2A, 0x2A, 0x2A, 0x0D, 0xA1, 0xFF,
  0x04, 0x0D, 0x91, 0xFF, 0x4A, 0x2A, 0x2A, 0x2A, 0x4A, 0x2A, 0x2A, 0x2A, 0x40, 0xDF, 0xD0, 0xD4,
  0x04, 0x0D, 0xFB, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_table_view() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_table_view_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_tab 24x24, 4-bit Alpha,  RLE, 50 bytes.
static const unsigned char ic_round_24_action_tab_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xE0, 0xDA, 0x03, 0x72, 0xFD, 0x73, 0xFD, 0x73, 0xFD,
  0x73, 0x0B, 0xFC, 0x77, 0x4C, 0x77, 0x4C, 0x77, 0x4C, 0x77, 0x4C, 0x77, 0x4C, 0x77, 0x4C, 0x77,
  0x4C, 0x77, 0x4C, 0x77, 0x4C, 0x03, 0x77, 0x20, 0x3A, 0x0D, 0xFF, 0xE8, 0x1D, 0x4D, 0xFF, 0xC0,
  0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_tab() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_tab_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_tab_unselected 24x24, 4-bit Alpha,  RLE, 54 bytes.
static const unsigned char ic_round_24_action_tab_unselected_data[] PROGMEM = {
  0x04, 0x0D, 0x2A, 0x2A, 0x2F, 0x98, 0x1D, 0x4D, 0x92, 0xA2, 0xA2, 0xFA, 0x0D, 0x75, 0xFB, 0x75,
  0xFD, 0x73, 0xFD, 0x73, 0x0B, 0xFA, 0x80, 0xD0, 0x0A, 0x77, 0x4C, 0x77, 0x4A, 0x80, 0xD0, 0x0A,
  0x77, 0x4C, 0x77, 0x4A, 0x80, 0xD0, 0x00, 0xD9, 0x2A, 0x2A, 0x2A, 0x2A, 0x29, 0x81, 0xD4, 0xD2,
  0xA2, 0xA2, 0xA2, 0xA2, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_tab_unselected() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_tab_unselected_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_task_alt 24x24, 4-bit Alpha,  RLE, 152 bytes.
static const unsigned char ic_round_24_action_task_alt_data[] PROGMEM = {
  0x68, 0x15, 0xAD, 0xA8, 0x1D, 0xA5, 0x73, 0x05, 0x0D, 0xF9, 0x0D, 0x71, 0x08, 0xA8, 0x1C, 0x62,
  0x28, 0x22, 0x6C, 0xC2, 0x81, 0x3A, 0x32, 0x08, 0xA0, 0x67, 0x38, 0x43, 0xEF, 0x60, 0x5A, 0x04,
  0x73, 0x82, 0x3E, 0xFA, 0x28, 0x1D, 0xF6, 0x73, 0x82, 0x3E, 0xFA, 0x28, 0x15, 0xFC, 0x73, 0x82,
  0x3E, 0xFA, 0x38, 0x1A, 0xF6, 0x72, 0x82, 0x3E, 0xFA, 0x28, 0x34, 0x2D, 0xF2, 0x71, 0x82, 0x3E,
  0xFA, 0x28, 0x41, 0xFD, 0xEF, 0x12, 0x07, 0x04, 0x38, 0x23, 0xEF, 0xA3, 0x82, 0x1F, 0xEE, 0x92,
  0x02, 0xA8, 0x45, 0x03, 0xEF, 0xA5, 0xA8, 0x1C, 0xF3, 0x20, 0x7A, 0x82, 0x7E, 0xFA, 0x58, 0x43,
  0xFC, 0x9F, 0x63, 0x07, 0xB0, 0xA6, 0x84, 0x7F, 0xA4, 0xFD, 0x48, 0x17, 0xFA, 0x78, 0x5D, 0xF5,
  0x0D, 0xF6, 0x40, 0x17, 0x81, 0x7F, 0xD2, 0x04, 0xA0, 0x47, 0x30, 0x5A, 0x04, 0x30, 0x8A, 0x06,
  0x71, 0x07, 0xA0, 0x85, 0x07, 0xA8, 0x6D, 0x62, 0x10, 0x37, 0xDA, 0x08, 0x70, 0x40, 0xDF, 0x90,
  0xD0, 0x57, 0x38, 0x65, 0x9C, 0xDD, 0xDA, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_task_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_task_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_terminal 24x24, 4-bit Alpha,  RLE, 67 bytes.
static const unsigned char ic_round_24_action_terminal_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xD8, 0x0C, 0x6F, 0x77, 0x2C, 0x28, 0x11, 0x71,
  0x74, 0xC2, 0x82, 0x6F, 0xD1, 0x73, 0xC3, 0x82, 0xBF, 0xD1, 0x72, 0xC4, 0x81, 0xBF, 0xD7, 0x2C,
  0x48, 0x1B, 0xFD, 0x72, 0xC3, 0x82, 0xBF, 0xD1, 0x72, 0xC2, 0x82, 0x6F, 0xD1, 0x20, 0xBC, 0x0B,
  0x2C, 0x28, 0x11, 0x71, 0x30, 0xBC, 0x0B, 0x2C, 0x77, 0x2A, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF,
  0xA0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_terminal() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_terminal_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_text_rotate_up 24x24, 4-bit Alpha,  RLE, 77 bytes.
static const unsigned char ic_round_24_action_text_rotate_up_data[] PROGMEM = {
  0x77, 0x00, 0x77, 0x71, 0x07, 0xA0, 0x77, 0x60, 0x2C, 0x02, 0x77, 0xA7, 0x38, 0x16, 0xCC, 0x3A,
  0x78, 0x12, 0x8E, 0xA0, 0xA3, 0xA5, 0x03, 0x0A, 0xB0, 0xD0, 0x34, 0xA3, 0x06, 0x0C, 0xA8, 0x2A,
  0x4F, 0xC5, 0xA2, 0x83, 0xCF, 0xC6, 0x12, 0x90, 0xC5, 0xA2, 0x83, 0xCF, 0xC6, 0x12, 0x90, 0xC5,
  0xA3, 0x06, 0x0C, 0xA8, 0x2A, 0x4F, 0xC5, 0xA5, 0x04, 0x0A, 0xB0, 0xD0, 0x34, 0xA7, 0x81, 0x28,
  0xEA, 0x0A, 0x3A, 0x73, 0x81, 0x6D, 0xC3, 0xA7, 0x72, 0xA7, 0x72, 0x00, 0xB2,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_text_rotate_up() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 4, 20, 19), Box(0, 0, 23, 23),
      ic_round_24_action_text_rotate_up_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_text_rotate_vertical 24x24, 4-bit Alpha,  RLE, 76 bytes.
static const unsigned char ic_round_24_action_text_rotate_vertical_data[] PROGMEM = {
  0x20, 0x0B, 0x77, 0x1A, 0x70, 0x0C, 0x6A, 0x60, 0x6A, 0x06, 0x5A, 0x60, 0xFC, 0x0D, 0x5A, 0x58,
  0x44, 0xF6, 0x6F, 0x44, 0xA5, 0x84, 0xAF, 0x11, 0xFA, 0x4A, 0x48, 0x12, 0xFA, 0x28, 0x1A, 0xF2,
  0x3A, 0x48, 0x18, 0xF4, 0x28, 0x14, 0xF8, 0x3A, 0x40, 0xEE, 0x0E, 0x3A, 0x38, 0x90, 0x6F, 0xDB,
  0xBB, 0xBD, 0xF6, 0x2A, 0x38, 0x1D, 0xF3, 0x48, 0x13, 0xFD, 0x2A, 0x30, 0xC0, 0xA6, 0x0A, 0x0C,
  0x2A, 0x76, 0x02, 0xC0, 0x27, 0x50, 0x7A, 0x07, 0x77, 0x00, 0x77, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_text_rotate_vertical() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 4, 19, 19), Box(0, 0, 23, 23),
      ic_round_24_action_text_rotate_vertical_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_text_rotation_angledown 24x24, 4-bit Alpha,  RLE, 102 bytes.
static const unsigned char ic_round_24_action_text_rotation_angledown_data[] PROGMEM = {
  0x77, 0x10, 0x37, 0x68, 0x33, 0x9E, 0xF7, 0x72, 0x86, 0x16, 0xCF, 0xEB, 0xF6, 0x78, 0x73, 0x9E,
  0xFE, 0x71, 0xAE, 0x60, 0x30, 0xDB, 0x07, 0x28, 0x11, 0xF9, 0x68, 0x48, 0xFC, 0xBF, 0xB2, 0x85,
  0x8F, 0x30, 0x27, 0x13, 0x02, 0x28, 0x4A, 0xFB, 0x1E, 0xC2, 0x82, 0x7F, 0xC1, 0x68, 0x3A, 0xFE,
  0xF6, 0x28, 0x31, 0xCF, 0xC1, 0x68, 0x2A, 0xFE, 0x13, 0x83, 0x1C, 0xFC, 0x15, 0x81, 0x6F, 0x95,
  0x83, 0x1C, 0xFC, 0x14, 0x81, 0xCF, 0x36, 0x83, 0x1C, 0xFC, 0x13, 0x00, 0xA7, 0x18, 0x31, 0xCF,
  0xC1, 0x76, 0x83, 0x1C, 0xFC, 0x17, 0x68, 0x41, 0xCF, 0xC1, 0x67, 0x50, 0x10, 0xCB, 0x76, 0x01,
  0x0E, 0xA7, 0x60, 0x6A, 0x0E, 0x50,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_text_rotation_angledown() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 19, 20), Box(0, 0, 23, 23),
      ic_round_24_action_text_rotation_angledown_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_text_rotation_angleup 24x24, 4-bit Alpha,  RLE, 103 bytes.
static const unsigned char ic_round_24_action_text_rotation_angleup_data[] PROGMEM = {
  0x10, 0x06, 0x77, 0x10, 0x3A, 0x81, 0xE9, 0x37, 0x68, 0x1E, 0xBA, 0xA8, 0x1C, 0x61, 0x73, 0x89,
  0x09, 0xE1, 0x18, 0xEF, 0xE9, 0x37, 0x18, 0x13, 0xF7, 0x20, 0x10, 0xEB, 0x0B, 0x71, 0x0C, 0x0E,
  0x28, 0x4B, 0xFA, 0x6C, 0xA2, 0x06, 0xA0, 0xE2, 0x84, 0x6F, 0x7B, 0xFA, 0x60, 0x1B, 0x20, 0x10,
  0xEA, 0x0A, 0x60, 0x10, 0xCB, 0x38, 0x19, 0xFB, 0x68, 0x41, 0xCF, 0xC1, 0x63, 0x81, 0x3F, 0xC5,
  0x83, 0x1C, 0xFC, 0x16, 0x81, 0xDF, 0x23, 0x83, 0x1C, 0xFC, 0x17, 0x04, 0x08, 0x38, 0x31, 0xCF,
  0xC1, 0x75, 0x83, 0x1C, 0xFC, 0x17, 0x58, 0x31, 0xCF, 0xC1, 0x75, 0x83, 0x1C, 0xFC, 0x17, 0x68,
  0x27, 0xFC, 0x17, 0x78, 0x12, 0x71, 0x72,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_text_rotation_angleup() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 4, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_text_rotation_angleup_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_text_rotation_down 24x24, 4-bit Alpha,  RLE, 77 bytes.
static const unsigned char ic_round_24_action_text_rotation_down_data[] PROGMEM = {
  0x20, 0x0B, 0x77, 0x2A, 0x77, 0x2A, 0x38, 0x1C, 0xD6, 0x73, 0xA3, 0x0A, 0xA8, 0x1E, 0x82, 0x7A,
  0x40, 0x30, 0xDB, 0x0A, 0x04, 0x5A, 0x58, 0x2C, 0xF4, 0xAA, 0x0C, 0x06, 0x3A, 0x50, 0xC9, 0x28,
  0x31, 0x6C, 0xFC, 0x2A, 0x50, 0xC9, 0x28, 0x31, 0x6C, 0xFC, 0x2A, 0x58, 0x2C, 0xF4, 0xAA, 0x0C,
  0x06, 0x3A, 0x40, 0x30, 0xDB, 0x0A, 0x04, 0x5A, 0x30, 0xAA, 0x81, 0xE8, 0x27, 0xA3, 0x81, 0xCD,
  0x67, 0x3A, 0x77, 0x02, 0xC0, 0x27, 0x60, 0x7A, 0x07, 0x77, 0x10, 0x07, 0x77,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_text_rotation_down() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 4, 20, 19), Box(0, 0, 23, 23),
      ic_round_24_action_text_rotation_down_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_text_rotation_none 24x24, 4-bit Alpha,  RLE, 71 bytes.
static const unsigned char ic_round_24_action_text_rotation_none_data[] PROGMEM = {
  0x60, 0x0C, 0x76, 0x06, 0xA0, 0x67, 0x58, 0x00, 0xC7, 0x48, 0x44, 0xF6, 0x6F, 0x47, 0x38, 0x4A,
  0xF1, 0x1F, 0xA7, 0x28, 0x12, 0xFA, 0x28, 0x1A, 0xF2, 0x71, 0x81, 0x8F, 0x42, 0x81, 0x4F, 0x87,
  0x10, 0xEE, 0x0E, 0x78, 0x90, 0x6F, 0xDB, 0xBB, 0xBD, 0xF6, 0x68, 0x1D, 0xF3, 0x48, 0x13, 0xFD,
  0x60, 0xC0, 0xA6, 0x0A, 0x0C, 0x77, 0x77, 0x50, 0x27, 0x71, 0x98, 0x17, 0x0B, 0xFF, 0x07, 0x0B,
  0xFF, 0x07, 0x76, 0x90, 0x77, 0x70, 0x22,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_text_rotation_none() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_text_rotation_none_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_theaters 24x24, 4-bit Alpha,  RLE, 42 bytes.
static const unsigned char ic_round_24_action_theaters_data[] PROGMEM = {
  0x00, 0xB2, 0x0B, 0xE0, 0xB2, 0x00, 0xBA, 0x2F, 0x92, 0x80, 0xC0, 0xF2, 0xF9, 0x2C, 0x2F, 0x92,
  0x80, 0xC0, 0xF2, 0xF9, 0x2C, 0x2F, 0x92, 0x80, 0xC0, 0xF2, 0xF9, 0x2C, 0x2F, 0x92, 0x80, 0xC0,
  0xF2, 0xF9, 0x2A, 0x00, 0xB2, 0x0B, 0xE0, 0xB2, 0x00, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_theaters() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 3, 19, 20), Box(0, 0, 23, 23),
      ic_round_24_action_theaters_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_thumb_down_off_alt 24x24, 4-bit Alpha,  RLE, 117 bytes.
static const unsigned char ic_round_24_action_thumb_down_off_alt_data[] PROGMEM = {
  0x40, 0x40, 0xDF, 0xA0, 0xD0, 0x42, 0x82, 0x4D, 0xD4, 0x40, 0xEF, 0xC0, 0xD2, 0x0D, 0xA0, 0xD3,
  0x81, 0x5F, 0xC7, 0x2A, 0x2C, 0x38, 0x1C, 0xF5, 0x72, 0xA2, 0xC2, 0x81, 0x3F, 0xE7, 0x3A, 0x2C,
  0x28, 0x1A, 0xF7, 0x73, 0xA2, 0xC1, 0x01, 0xA0, 0x17, 0x3A, 0x2C, 0x18, 0x18, 0xFA, 0x74, 0xA2,
  0xC1, 0x81, 0xEF, 0x37, 0x4A, 0x2C, 0x81, 0x3F, 0xC7, 0x5A, 0x2C, 0x82, 0x3F, 0xC1, 0x74, 0xA2,
  0x0D, 0xA8, 0x1D, 0x0D, 0xFA, 0x0A, 0x3A, 0x28, 0x54, 0xDD, 0x40, 0x2B, 0xF9, 0x07, 0x28, 0x18,
  0xFD, 0x77, 0x18, 0x3C, 0xF3, 0x07, 0xA0, 0x47, 0x71, 0xA1, 0x07, 0xA0, 0x57, 0x71, 0x82, 0x3F,
  0xC7, 0xA0, 0x57, 0x72, 0x81, 0x6F, 0xEA, 0x05, 0x77, 0x30, 0x9B, 0x05, 0x77, 0x40, 0x7A, 0x05,
  0x77, 0x60, 0x40, 0x27, 0x50,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_thumb_down_off_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 3, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_thumb_down_off_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_thumb_down 24x24, 4-bit Alpha,  RLE, 88 bytes.
static const unsigned char ic_round_24_action_thumb_down_data[] PROGMEM = {
  0x40, 0x40, 0xDF, 0xA0, 0xD0, 0x42, 0x82, 0x4D, 0xD4, 0x40, 0xEF, 0xC0, 0xD2, 0x0D, 0xA0, 0xD3,
  0x05, 0xFE, 0x2C, 0x30, 0xCF, 0xE2, 0xC2, 0x03, 0xFF, 0x2C, 0x20, 0xAF, 0xF2, 0xC1, 0x01, 0xFF,
  0x92, 0xC1, 0x08, 0xFF, 0x92, 0xC1, 0x0E, 0xFF, 0x92, 0xC0, 0x3F, 0xFA, 0x2C, 0x03, 0xFF, 0xA2,
  0x0D, 0xA8, 0x1D, 0x0D, 0xFF, 0x92, 0x85, 0x4D, 0xD4, 0x02, 0xBF, 0xE0, 0xD7, 0x71, 0x0C, 0xE0,
  0x47, 0x71, 0xE0, 0x57, 0x71, 0x03, 0xD0, 0x57, 0x72, 0x06, 0xC0, 0x57, 0x73, 0x09, 0xB0, 0x57,
  0x74, 0x07, 0xA0, 0x57, 0x76, 0x04, 0x02, 0x75,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_thumb_down() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 3, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_thumb_down_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_thumbs_up_down 24x24, 4-bit Alpha,  RLE, 106 bytes.
static const unsigned char ic_round_24_action_thumbs_up_down_data[] PROGMEM = {
  0x40, 0x20, 0x77, 0x77, 0x82, 0x2E, 0xF6, 0x77, 0x50, 0x20, 0xEA, 0x05, 0x77, 0x40, 0x20, 0xEB,
  0x02, 0x77, 0x30, 0x20, 0xEB, 0x0E, 0x77, 0x40, 0xCF, 0xA0, 0xD0, 0x47, 0x5F, 0xC0, 0xE7, 0x5F,
  0xC0, 0xE7, 0x5F, 0xC0, 0x97, 0x5F, 0xC0, 0x27, 0x5F, 0xB0, 0xB3, 0x03, 0x0D, 0xE0, 0xD0, 0x4F,
  0xB0, 0x43, 0x0D, 0xF9, 0x00, 0xDF, 0x90, 0xD3, 0x04, 0xFB, 0x04, 0x0D, 0xE0, 0xD0, 0x33, 0x0B,
  0xFB, 0x75, 0x02, 0xFC, 0x75, 0x09, 0xFC, 0x75, 0x0E, 0xFC, 0x75, 0x0E, 0xFC, 0x75, 0x05, 0x0D,
  0xFA, 0x0C, 0x77, 0x40, 0xEB, 0x0E, 0x02, 0x77, 0x30, 0x2B, 0x0E, 0x02, 0x77, 0x40, 0x5A, 0x0E,
  0x02, 0x77, 0x58, 0x26, 0xFE, 0x27, 0x77, 0x07, 0x02, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_thumbs_up_down() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(0, 0, 23, 23), Box(0, 0, 23, 23),
      ic_round_24_action_thumbs_up_down_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_thumb_up_off_alt 24x24, 4-bit Alpha,  RLE, 88 bytes.
static const unsigned char ic_round_24_action_thumb_up_off_alt_data[] PROGMEM = {
  0x75, 0x02, 0x04, 0x77, 0x60, 0x5A, 0x07, 0x77, 0x40, 0x5B, 0x09, 0x77, 0x30, 0x5C, 0x06, 0x77,
  0x20, 0x5D, 0x03, 0x77, 0x10, 0x5E, 0x77, 0x10, 0x4E, 0x0C, 0x77, 0x10, 0xDF, 0xE8, 0x5B, 0x20,
  0x4D, 0xD4, 0x2F, 0xF9, 0x81, 0xD0, 0xDA, 0x0D, 0x2F, 0xFA, 0x03, 0xC2, 0xFF, 0xA0, 0x3C, 0x2F,
  0xF9, 0x0E, 0x1C, 0x2F, 0xF9, 0x08, 0x1C, 0x2F, 0xF9, 0x01, 0x1C, 0x2F, 0xF0, 0xA2, 0xC2, 0xFF,
  0x03, 0x2C, 0x2F, 0xE0, 0xC3, 0xC2, 0xFE, 0x06, 0x30, 0xDA, 0x0D, 0x20, 0xDF, 0xC0, 0xE4, 0x82,
  0x4D, 0xD4, 0x20, 0x40, 0xDF, 0xA0, 0xD0, 0x44,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_thumb_up_off_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 23, 20), Box(0, 0, 23, 23),
      ic_round_24_action_thumb_up_off_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_thumb_up 24x24, 4-bit Alpha,  RLE, 88 bytes.
static const unsigned char ic_round_24_action_thumb_up_data[] PROGMEM = {
  0x75, 0x02, 0x04, 0x77, 0x60, 0x5A, 0x07, 0x77, 0x40, 0x5B, 0x09, 0x77, 0x30, 0x5C, 0x06, 0x77,
  0x20, 0x5D, 0x03, 0x77, 0x10, 0x5E, 0x77, 0x10, 0x4E, 0x0C, 0x77, 0x10, 0xDF, 0xE8, 0x5B, 0x20,
  0x4D, 0xD4, 0x2F, 0xF9, 0x81, 0xD0, 0xDA, 0x0D, 0x2F, 0xFA, 0x03, 0xC2, 0xFF, 0xA0, 0x3C, 0x2F,
  0xF9, 0x0E, 0x1C, 0x2F, 0xF9, 0x08, 0x1C, 0x2F, 0xF9, 0x01, 0x1C, 0x2F, 0xF0, 0xA2, 0xC2, 0xFF,
  0x03, 0x2C, 0x2F, 0xE0, 0xC3, 0xC2, 0xFE, 0x06, 0x30, 0xDA, 0x0D, 0x20, 0xDF, 0xC0, 0xE4, 0x82,
  0x4D, 0xD4, 0x20, 0x40, 0xDF, 0xA0, 0xD0, 0x44,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_thumb_up() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 23, 20), Box(0, 0, 23, 23),
      ic_round_24_action_thumb_up_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_timeline 24x24, 4-bit Alpha,  RLE, 83 bytes.
static const unsigned char ic_round_24_action_timeline_data[] PROGMEM = {
  0x77, 0x48, 0x24, 0xDD, 0x47, 0x82, 0x4D, 0xD4, 0x70, 0xDA, 0x0D, 0x70, 0xDA, 0x0D, 0x60, 0x1B,
  0x0D, 0x60, 0x1C, 0x01, 0x40, 0x10, 0xCA, 0x0D, 0x04, 0x50, 0x10, 0xCC, 0x0C, 0x01, 0x28, 0x31,
  0xCF, 0xC1, 0x68, 0x95, 0x1C, 0xFC, 0x11, 0xCF, 0xC1, 0x1C, 0xFC, 0x16, 0x83, 0x1C, 0xFC, 0x12,
  0x01, 0x0C, 0xC0, 0xC0, 0x16, 0x83, 0x1C, 0xFC, 0x14, 0x01, 0xC0, 0x15, 0x04, 0x0D, 0xA0, 0xC0,
  0x16, 0x0D, 0xA0, 0xD6, 0x0D, 0xB0, 0x17, 0x82, 0x4D, 0xD4, 0x60, 0xDA, 0x0D, 0x77, 0x48, 0x24,
  0xDD, 0x47, 0x74,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_timeline() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 6, 22, 17), Box(0, 0, 23, 23),
      ic_round_24_action_timeline_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_tips_and_updates 24x24, 4-bit Alpha,  RLE, 102 bytes.
static const unsigned char ic_round_24_action_tips_and_updates_data[] PROGMEM = {
  0x77, 0x30, 0x03, 0x77, 0x70, 0x0A, 0x71, 0x86, 0x18, 0xCE, 0xEC, 0x81, 0x30, 0x30, 0xAA, 0x0A,
  0x03, 0x50, 0x7F, 0x90, 0x72, 0x03, 0x0A, 0xA0, 0xA0, 0x34, 0x08, 0xFB, 0x08, 0x30, 0x0A, 0x50,
  0x4F, 0xD0, 0x42, 0x00, 0x35, 0x0D, 0xFD, 0x0D, 0x58, 0x23, 0x30, 0x3F, 0xF0, 0x33, 0x83, 0x3C,
  0xC3, 0x6F, 0xF0, 0x63, 0x83, 0x3C, 0xC3, 0x7F, 0xF0, 0x74, 0x82, 0x33, 0x06, 0xFF, 0x06, 0x70,
  0x3F, 0xF0, 0x37, 0x10, 0xDF, 0xD0, 0xD7, 0x20, 0x4F, 0xD0, 0x47, 0x30, 0x7F, 0xB0, 0x77, 0x50,
  0x6F, 0x90, 0x78, 0x0C, 0x10, 0x0B, 0xE0, 0xB7, 0x71, 0x0B, 0xE0, 0xB8, 0x0C, 0x40, 0x0D, 0xA0,
  0xD7, 0x75, 0x82, 0x4D, 0xD4, 0x76,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_tips_and_updates() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 0, 23, 21), Box(0, 0, 23, 23),
      ic_round_24_action_tips_and_updates_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_toc 24x24, 4-bit Alpha,  RLE, 29 bytes.
static const unsigned char ic_round_24_action_toc_data[] PROGMEM = {
  0x0B, 0xFD, 0x0B, 0x2A, 0x0B, 0xFD, 0x0B, 0x2A, 0x80, 0xC0, 0x00, 0xBF, 0xD0, 0xB2, 0xA0, 0xBF,
  0xD0, 0xB2, 0xA8, 0x0C, 0x00, 0x0B, 0xFD, 0x0B, 0x2A, 0x0B, 0xFD, 0x0B, 0x2A,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_toc() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 7, 20, 16), Box(0, 0, 23, 23),
      ic_round_24_action_toc_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_today 24x24, 4-bit Alpha,  RLE, 51 bytes.
static const unsigned char ic_round_24_action_today_data[] PROGMEM = {
  0x30, 0x0B, 0x71, 0x00, 0xB6, 0xA7, 0x1A, 0x30, 0x40, 0xDF, 0xF8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD8,
  0x0E, 0x4F, 0x77, 0xC7, 0x7C, 0x20, 0xBB, 0x0B, 0x7C, 0x2D, 0x7C, 0x2D, 0x7C, 0x2D, 0x7C, 0x20,
  0xBB, 0x0B, 0x7C, 0x77, 0xC7, 0x7C, 0x77, 0xC0, 0x37, 0x50, 0x3A, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D,
  0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_today() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 1, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_today_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_token 24x24, 4-bit Alpha,  RLE, 116 bytes.
static const unsigned char ic_round_24_action_token_data[] PROGMEM = {
  0x78, 0x22, 0x99, 0x27, 0x50, 0x10, 0x9C, 0x09, 0x01, 0x72, 0x07, 0x0E, 0xE0, 0xE0, 0x76, 0x05,
  0x0D, 0xFB, 0x0D, 0x06, 0x30, 0x7F, 0xF0, 0x73, 0x03, 0x0C, 0xFB, 0x0C, 0x03, 0x20, 0x90, 0x12,
  0x82, 0x5D, 0xD4, 0x28, 0x24, 0xDD, 0x52, 0x83, 0x19, 0xFE, 0x77, 0x50, 0x70, 0xEC, 0x0D, 0x05,
  0x28, 0x24, 0xDD, 0x42, 0x05, 0x0D, 0xF9, 0x81, 0x10, 0xDA, 0x81, 0xD0, 0x1F, 0xB8, 0x11, 0x0D,
  0xA8, 0x1D, 0x01, 0xFB, 0x86, 0x50, 0x4D, 0xD4, 0x05, 0xFB, 0x0D, 0x01, 0x40, 0x10, 0xDF, 0xC0,
  0xD0, 0x52, 0x05, 0x0D, 0xE0, 0xCF, 0x2F, 0x81, 0xC2, 0xCE, 0x2E, 0x0C, 0x02, 0x20, 0x50, 0xDC,
  0x2C, 0x0D, 0x05, 0x60, 0x70, 0xEA, 0x2A, 0x0E, 0x07, 0x72, 0x01, 0x09, 0x92, 0x90, 0x90, 0x17,
  0x50, 0x22, 0x02, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_token() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 2, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_token_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_toll 24x24, 4-bit Alpha,  RLE, 135 bytes.
static const unsigned char ic_round_24_action_toll_data[] PROGMEM = {
  0x40, 0x20, 0x34, 0x86, 0x28, 0xCE, 0xEC, 0x82, 0x78, 0x17, 0xFE, 0x30, 0x9F, 0x90, 0x95, 0x0A,
  0xA0, 0x72, 0x0B, 0xA0, 0x80, 0x32, 0x03, 0x08, 0xA0, 0xB3, 0x82, 0x8F, 0xE3, 0x28, 0x29, 0xFD,
  0x26, 0x84, 0x2D, 0xF9, 0x01, 0xA0, 0x32, 0x02, 0xA0, 0x27, 0x10, 0x2A, 0x82, 0x28, 0xF9, 0x38,
  0x18, 0xF8, 0x73, 0x84, 0x8F, 0x8C, 0xF3, 0x38, 0x1C, 0xF3, 0x73, 0x84, 0x3F, 0xCE, 0xF1, 0x30,
  0xE9, 0x75, 0x98, 0x2E, 0xEF, 0x13, 0x0E, 0x97, 0x59, 0x82, 0xEC, 0xF3, 0x38, 0x1C, 0xF3, 0x73,
  0x84, 0x3F, 0xC8, 0xF9, 0x38, 0x18, 0xF8, 0x73, 0x82, 0x8F, 0x81, 0xA0, 0x32, 0x02, 0xA0, 0x27,
  0x10, 0x2A, 0x84, 0x20, 0x8F, 0xE3, 0x28, 0x29, 0xFD, 0x26, 0x82, 0x2D, 0xF9, 0x30, 0xAA, 0x07,
  0x20, 0xBA, 0x08, 0x03, 0x20, 0x30, 0x8A, 0x0B, 0x58, 0x17, 0xFE, 0x30, 0x9F, 0x90, 0x97, 0x02,
  0x03, 0x48, 0x62, 0x8C, 0xEE, 0xC8, 0x24,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_toll() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 4, 22, 19), Box(0, 0, 23, 23),
      ic_round_24_action_toll_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_touch_app 24x24, 4-bit Alpha,  RLE, 99 bytes.
static const unsigned char ic_round_24_action_touch_app_data[] PROGMEM = {
  0x48, 0x38, 0xCE, 0xB5, 0x71, 0x01, 0x0D, 0xD0, 0x87, 0x87, 0xAF, 0xB2, 0x05, 0xEF, 0x46, 0xA8,
  0x51, 0xAE, 0x57, 0xF9, 0x58, 0x22, 0xFC, 0x2A, 0x82, 0xB3, 0xFB, 0x58, 0x21, 0xFC, 0x3A, 0x82,
  0xC3, 0xF9, 0x68, 0x1A, 0xC3, 0xA8, 0x2C, 0x3F, 0x46, 0x81, 0x1A, 0x3A, 0x81, 0xC3, 0x97, 0x20,
  0x3A, 0x0C, 0x74, 0x03, 0xA0, 0xC7, 0x40, 0x3A, 0x81, 0xD7, 0x27, 0x20, 0x3D, 0x0A, 0x02, 0x70,
  0x3F, 0x0A, 0x02, 0x50, 0x3F, 0xA8, 0x42, 0x46, 0x30, 0x3F, 0xA0, 0x60, 0xEB, 0x0D, 0xFA, 0x05,
  0x08, 0xFE, 0x81, 0x30, 0x9F, 0xD0, 0x12, 0x09, 0xFB, 0x0E, 0x40, 0x9F, 0xA0, 0xB5, 0x07, 0x0E,
  0xE0, 0xD0, 0x31,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_touch_app() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 1, 19, 21), Box(0, 0, 23, 23),
      ic_round_24_action_touch_app_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_tour 24x24, 4-bit Alpha,  RLE, 52 bytes.
static const unsigned char ic_round_24_action_tour_data[] PROGMEM = {
  0x00, 0xB7, 0x7A, 0x77, 0xFF, 0x90, 0x4F, 0xF9, 0x05, 0xFF, 0x0E, 0x1E, 0x82, 0xB1, 0x1B, 0xC0,
  0x91, 0xE0, 0x12, 0x01, 0xC0, 0x31, 0xE0, 0x12, 0x01, 0xC0, 0x31, 0xE8, 0x2B, 0x11, 0xBC, 0x09,
  0x1F, 0xF0, 0xE1, 0xFF, 0x90, 0x5F, 0xF9, 0x04, 0xA7, 0x7A, 0x77, 0xA7, 0x7A, 0x77, 0xA7, 0x7A,
  0x77, 0xA7, 0x7A, 0x77,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_tour() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 2, 20, 21), Box(0, 0, 23, 23),
      ic_round_24_action_tour_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_track_changes 24x24, 4-bit Alpha,  RLE, 171 bytes.
static const unsigned char ic_round_24_action_track_changes_data[] PROGMEM = {
  0x68, 0x35, 0xAD, 0xED, 0x76, 0x04, 0x0D, 0xD7, 0x50, 0x8A, 0x81, 0xC6, 0x2A, 0x74, 0x08, 0xA0,
  0x63, 0xA5, 0x05, 0x06, 0x30, 0x4A, 0x04, 0x20, 0x60, 0xBA, 0x58, 0x1D, 0xF4, 0x28, 0x4D, 0xF6,
  0x01, 0xCC, 0x58, 0x56, 0xFD, 0x05, 0xFC, 0x28, 0x2C, 0xFD, 0x5A, 0x20, 0x60, 0x92, 0x89, 0x1C,
  0xF4, 0xAF, 0x60, 0x6F, 0xD1, 0x1A, 0x28, 0x96, 0xBF, 0x50, 0x6F, 0xAC, 0xF2, 0x0C, 0xF5, 0x04,
  0xA8, 0x90, 0x40, 0x4F, 0xB0, 0x2F, 0xDE, 0x92, 0x83, 0xEF, 0x10, 0xDA, 0x0D, 0x29, 0x0E, 0x2A,
  0x0E, 0x92, 0x0E, 0x92, 0x0D, 0xA0, 0xD2, 0x90, 0xE2, 0x98, 0xB3, 0xED, 0xF2, 0x0B, 0xF5, 0x04,
  0xDD, 0x40, 0x5F, 0xC0, 0x2F, 0xD9, 0xF6, 0x06, 0xFD, 0x14, 0x89, 0x11, 0xDF, 0x60, 0x7F, 0xA5,
  0xFC, 0x28, 0x2B, 0xFD, 0x42, 0x82, 0x5D, 0xFC, 0x28, 0x90, 0xDF, 0x50, 0xDF, 0x60, 0x1B, 0xE8,
  0x4C, 0x10, 0x7F, 0xD2, 0x05, 0xA0, 0x42, 0x06, 0x0B, 0xA0, 0xC0, 0x62, 0x04, 0xA0, 0x43, 0x82,
  0x8F, 0xE6, 0x71, 0x07, 0xA0, 0x85, 0x09, 0xA8, 0x1C, 0x62, 0x28, 0x12, 0x7C, 0xA0, 0x87, 0x05,
  0x0E, 0xF9, 0x0D, 0x05, 0x73, 0x86, 0x5B, 0xDF, 0xED, 0xA5, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_track_changes() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_track_changes_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_transcribe 24x24, 4-bit Alpha,  RLE, 121 bytes.
static const unsigned char ic_round_24_action_transcribe_data[] PROGMEM = {
  0x77, 0x20, 0x40, 0x37, 0x75, 0x04, 0xA0, 0x17, 0x74, 0x81, 0xDF, 0xD7, 0x28, 0x41, 0xAD, 0xDA,
  0x13, 0x05, 0xA0, 0x57, 0x10, 0x10, 0xEC, 0x0E, 0x01, 0x28, 0x1A, 0xFE, 0x28, 0x18, 0xE4, 0x40,
  0xAE, 0x0A, 0x28, 0x1D, 0xFB, 0x28, 0x1E, 0xF8, 0x40, 0xDE, 0x0D, 0x28, 0x3E, 0xF8, 0x03, 0xA0,
  0x64, 0x0D, 0xE0, 0xD2, 0x83, 0xEF, 0x80, 0x3A, 0x05, 0x40, 0xAE, 0x0A, 0x28, 0x1D, 0xFA, 0x28,
  0x1E, 0xF8, 0x40, 0x10, 0xEC, 0x0E, 0x01, 0x28, 0x19, 0xFD, 0x28, 0x17, 0xE4, 0x58, 0x41, 0xAD,
  0xDA, 0x13, 0x04, 0xA0, 0x57, 0x75, 0x81, 0xDF, 0xD7, 0x82, 0x38, 0xBD, 0xA8, 0x2D, 0xB8, 0x32,
  0x04, 0xA0, 0x14, 0x05, 0x0C, 0xFB, 0x83, 0xC5, 0x04, 0x44, 0x06, 0xFF, 0x06, 0x60, 0xDF, 0xF0,
  0xD6, 0xFF, 0xA6, 0xFF, 0xA6, 0x0B, 0xFF, 0x0B, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_transcribe() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_transcribe_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_translate 24x24, 4-bit Alpha,  RLE, 125 bytes.
static const unsigned char ic_round_24_action_translate_data[] PROGMEM = {
  0x70, 0x0B, 0x77, 0x6A, 0x76, 0x0B, 0xFF, 0x0B, 0x60, 0xBF, 0xF0, 0xB7, 0x72, 0x81, 0x1F, 0xD7,
  0x75, 0x81, 0x8F, 0x77, 0x60, 0x80, 0xD4, 0x81, 0xEE, 0x17, 0x68, 0x17, 0xF9, 0x28, 0x19, 0xF8,
  0x77, 0x18, 0x4D, 0xF4, 0x5F, 0xD4, 0x81, 0x7E, 0x77, 0x28, 0x43, 0xFE, 0xEF, 0x33, 0x01, 0xB0,
  0x17, 0x20, 0x8A, 0x08, 0x48, 0x36, 0xFE, 0xF6, 0x71, 0x04, 0xC0, 0x43, 0x83, 0xCF, 0x5F, 0xC7,
  0x04, 0xA0, 0x07, 0xA8, 0x74, 0x02, 0xFC, 0x0C, 0xF3, 0x50, 0x5A, 0x07, 0x28, 0x91, 0x7F, 0x90,
  0x8F, 0x60, 0x6F, 0x84, 0x05, 0xA0, 0x74, 0x89, 0x03, 0x10, 0xEF, 0x10, 0x1F, 0xE4, 0x81, 0xDF,
  0x77, 0x04, 0xF0, 0x43, 0x00, 0x57, 0x10, 0xAF, 0x0A, 0x75, 0x81, 0x1F, 0xE5, 0x81, 0xEF, 0x17,
  0x48, 0x16, 0xF8, 0x58, 0x18, 0xF6, 0x74, 0x81, 0x5E, 0x25, 0x81, 0x2E, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_translate() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 22, 21), Box(0, 0, 23, 23),
      ic_round_24_action_translate_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_trending_down 24x24, 4-bit Alpha,  RLE, 76 bytes.
static const unsigned char ic_round_24_action_trending_down_data[] PROGMEM = {
  0x81, 0x17, 0x17, 0x73, 0x82, 0x7F, 0xC1, 0x77, 0x28, 0x31, 0xCF, 0xC1, 0x58, 0x12, 0x71, 0x71,
  0x83, 0x1C, 0xFC, 0x13, 0x83, 0x2E, 0xFC, 0x17, 0x18, 0x61, 0xCF, 0xC1, 0x02, 0xEB, 0x0C, 0x01,
  0x71, 0x89, 0x31, 0xCF, 0xC3, 0xEF, 0xB1, 0xCF, 0xC1, 0x71, 0x01, 0x0C, 0xB0, 0xB2, 0x83, 0x1C,
  0xFC, 0x12, 0x02, 0x58, 0x21, 0xCF, 0xB4, 0x84, 0x1C, 0xFC, 0x17, 0x97, 0x04, 0x68, 0x21, 0xCF,
  0xEA, 0x77, 0x10, 0x10, 0xEB, 0x77, 0x10, 0x7C, 0x77, 0x02, 0xC0, 0xE0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_trending_down() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 6, 21, 17), Box(0, 0, 23, 23),
      ic_round_24_action_trending_down_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_trending_flat 24x24, 4-bit Alpha,  RLE, 25 bytes.
static const unsigned char ic_round_24_action_trending_flat_data[] PROGMEM = {
  0x77, 0x10, 0x27, 0x74, 0x90, 0x77, 0x73, 0xA8, 0x17, 0x0B, 0xFF, 0xB0, 0x70, 0xBF, 0xFB, 0x07,
  0x77, 0x1A, 0x07, 0x77, 0x29, 0x07, 0x77, 0x30, 0x23,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_trending_flat() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 8, 21, 15), Box(0, 0, 23, 23),
      ic_round_24_action_trending_flat_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_trending_up 24x24, 4-bit Alpha,  RLE, 75 bytes.
static const unsigned char ic_round_24_action_trending_up_data[] PROGMEM = {
  0x77, 0x02, 0xC0, 0xE7, 0x71, 0x07, 0xC7, 0x71, 0x01, 0x0E, 0xB7, 0x04, 0x68, 0x21, 0xCF, 0xEA,
  0x58, 0x21, 0xCF, 0xB4, 0x84, 0x1C, 0xFC, 0x17, 0x94, 0x01, 0x0C, 0xB0, 0xB2, 0x83, 0x1C, 0xFC,
  0x12, 0x02, 0x38, 0x93, 0x1C, 0xFC, 0x3E, 0xFB, 0x1C, 0xFC, 0x16, 0x86, 0x1C, 0xFC, 0x10, 0x2E,
  0xB0, 0xC0, 0x16, 0x83, 0x1C, 0xFC, 0x13, 0x83, 0x2E, 0xFC, 0x16, 0x83, 0x1C, 0xFC, 0x15, 0x81,
  0x27, 0x17, 0x82, 0x7F, 0xC1, 0x77, 0x28, 0x11, 0x71, 0x77, 0x30,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_trending_up() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 6, 21, 17), Box(0, 0, 23, 23),
      ic_round_24_action_trending_up_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_troubleshoot 24x24, 4-bit Alpha,  RLE, 145 bytes.
static const unsigned char ic_round_24_action_troubleshoot_data[] PROGMEM = {
  0x68, 0x62, 0x8C, 0xFE, 0xC8, 0x27, 0x50, 0x8F, 0x90, 0x97, 0x30, 0xBA, 0x08, 0x03, 0x20, 0x30,
  0x9A, 0x0B, 0x71, 0x82, 0x8F, 0xD2, 0x68, 0x23, 0xDF, 0x96, 0x02, 0xA8, 0x23, 0x5E, 0x45, 0x03,
  0xA0, 0x25, 0x85, 0x8F, 0x90, 0xBF, 0xA6, 0x81, 0x9F, 0x85, 0x82, 0xCF, 0x31, 0xA8, 0x3E, 0x05,
  0xE5, 0x28, 0x14, 0xFC, 0x71, 0x86, 0x6F, 0x8F, 0x2C, 0xFD, 0x39, 0x0E, 0x30, 0xCD, 0x86, 0xD2,
  0xF7, 0xFB, 0xF4, 0x29, 0x0E, 0x30, 0x58, 0x01, 0x78, 0x92, 0x20, 0xEE, 0xF2, 0xDF, 0x43, 0xFC,
  0x58, 0x13, 0x75, 0x38, 0x90, 0xAF, 0xC0, 0x37, 0x19, 0xF8, 0x50, 0x2A, 0x03, 0x28, 0x14, 0xE5,
  0x30, 0x3A, 0x02, 0x68, 0x29, 0xFE, 0x36, 0x82, 0x2D, 0xF8, 0x71, 0x0B, 0xA8, 0x49, 0x31, 0x03,
  0x8B, 0x0C, 0x01, 0x71, 0x09, 0xF9, 0x83, 0x9C, 0xFC, 0x17, 0x18, 0x94, 0x28, 0xCF, 0xEC, 0x82,
  0x01, 0xCF, 0xC1, 0x77, 0x38, 0x31, 0xCF, 0xC1, 0x77, 0x38, 0x21, 0xCF, 0x77, 0x74, 0x81, 0x17,
  0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_troubleshoot() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_troubleshoot_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_try 24x24, 4-bit Alpha,  RLE, 68 bytes.
static const unsigned char ic_round_24_action_try_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDF, 0xFF, 0xF9, 0x00, 0xEF, 0xFC, 0x00, 0x4F,
  0xFB, 0x0C, 0x20, 0xDF, 0xF9, 0x0C, 0x04, 0x20, 0x40, 0xDF, 0xD0, 0xD0, 0x46, 0x04, 0x0E, 0xFB,
  0x0D, 0x04, 0x60, 0x40, 0xEF, 0xD0, 0xD0, 0x42, 0x04, 0x0D, 0xFF, 0x90, 0xD2, 0x0D, 0xFF, 0xB0,
  0x04, 0xFF, 0xC0, 0x0E, 0x80, 0xD4, 0xF0, 0xDF, 0xFC, 0x0D, 0x04, 0xB0, 0x77, 0x72, 0xA0, 0x77,
  0x73, 0x00, 0x57, 0x74,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_try() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_try_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_turned_in_not 24x24, 4-bit Alpha,  RLE, 52 bytes.
static const unsigned char ic_round_24_action_turned_in_not_data[] PROGMEM = {
  0x04, 0x0D, 0xFB, 0x81, 0xD4, 0xDF, 0xD0, 0xDA, 0x03, 0x71, 0x03, 0xC7, 0x3C, 0x73, 0xC7, 0x3C,
  0x73, 0xC7, 0x3C, 0x73, 0xC7, 0x3C, 0x73, 0xC7, 0x3C, 0x73, 0xC2, 0x84, 0x18, 0xEE, 0x81, 0x2C,
  0x03, 0x0A, 0xE0, 0xA0, 0x3F, 0x82, 0x93, 0x39, 0xF8, 0x1E, 0x71, 0x48, 0x11, 0x7E, 0xA0, 0xC0,
  0x57, 0x30, 0x50, 0xC0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_turned_in_not() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 18, 20), Box(0, 0, 23, 23),
      ic_round_24_action_turned_in_not_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_turned_in 24x24, 4-bit Alpha,  RLE, 25 bytes.
static const unsigned char ic_round_24_action_turned_in_data[] PROGMEM = {
  0x04, 0x0D, 0xFB, 0x81, 0xD4, 0xDF, 0xD0, 0xD8, 0x0A, 0xE7, 0xF8, 0x29, 0x33, 0x9F, 0x81, 0xE7,
  0x14, 0x81, 0x17, 0xEA, 0x0C, 0x05, 0x73, 0x05, 0x0C,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_turned_in() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(5, 3, 18, 20), Box(0, 0, 23, 23),
      ic_round_24_action_turned_in_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_unfold_less_double 24x24, 4-bit Alpha,  RLE, 94 bytes.
static const unsigned char ic_round_24_action_unfold_less_double_data[] PROGMEM = {
  0x10, 0x60, 0x44, 0x82, 0x46, 0x01, 0xA0, 0x52, 0x05, 0xA8, 0x11, 0x07, 0xA0, 0x05, 0xA0, 0x73,
  0x07, 0xC0, 0x75, 0x07, 0xA0, 0x74, 0x89, 0x06, 0x40, 0x55, 0x04, 0x60, 0x1A, 0x05, 0x20, 0x5A,
  0x81, 0x10, 0x7A, 0x00, 0x5A, 0x07, 0x30, 0x7C, 0x07, 0x50, 0x7A, 0x07, 0x70, 0x05, 0x77, 0x77,
  0x00, 0x57, 0x07, 0xA0, 0x75, 0x07, 0xC0, 0x73, 0x07, 0xA0, 0x05, 0xA8, 0x17, 0x01, 0xA0, 0x52,
  0x05, 0xA8, 0x90, 0x10, 0x64, 0x05, 0x50, 0x46, 0x40, 0x7A, 0x07, 0x50, 0x7C, 0x07, 0x30, 0x7A,
  0x00, 0x5A, 0x81, 0x70, 0x1A, 0x05, 0x20, 0x5A, 0x82, 0x10, 0x64, 0x40, 0x40, 0x61,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_unfold_less_double() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(7, 0, 16, 23), Box(0, 0, 23, 23),
      ic_round_24_action_unfold_less_double_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_unfold_more_double 24x24, 4-bit Alpha,  RLE, 94 bytes.
static const unsigned char ic_round_24_action_unfold_more_double_data[] PROGMEM = {
  0x40, 0x05, 0x70, 0x7A, 0x07, 0x50, 0x7C, 0x07, 0x30, 0x7A, 0x00, 0x5A, 0x81, 0x70, 0x1A, 0x05,
  0x20, 0x5A, 0x89, 0x01, 0x06, 0x30, 0x55, 0x04, 0x64, 0x07, 0xA0, 0x75, 0x07, 0xC0, 0x73, 0x07,
  0xA0, 0x05, 0xA8, 0x17, 0x01, 0xA0, 0x52, 0x05, 0xA8, 0x21, 0x06, 0x34, 0x04, 0x06, 0x77, 0x71,
  0x06, 0x04, 0x48, 0x23, 0x60, 0x1A, 0x05, 0x20, 0x5A, 0x81, 0x10, 0x7A, 0x00, 0x5A, 0x07, 0x30,
  0x7C, 0x07, 0x50, 0x7A, 0x07, 0x48, 0x90, 0x64, 0x05, 0x50, 0x36, 0x01, 0xA0, 0x52, 0x05, 0xA8,
  0x11, 0x07, 0xA0, 0x05, 0xA0, 0x73, 0x07, 0xC0, 0x75, 0x07, 0xA0, 0x77, 0x00, 0x54,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_unfold_more_double() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(7, 0, 16, 23), Box(0, 0, 23, 23),
      ic_round_24_action_unfold_more_double_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_unpublished 24x24, 4-bit Alpha,  RLE, 148 bytes.
static const unsigned char ic_round_24_action_unpublished_data[] PROGMEM = {
  0x78, 0x15, 0xAD, 0xA8, 0x1D, 0xA5, 0x70, 0x90, 0x62, 0x02, 0x0D, 0xF9, 0x0D, 0x04, 0x40, 0x1A,
  0x07, 0x20, 0xAF, 0xB0, 0x84, 0x05, 0xA0, 0x72, 0x0A, 0xFB, 0x08, 0x40, 0x8A, 0x07, 0x20, 0xAF,
  0xB0, 0x43, 0x0D, 0xB0, 0x72, 0x0A, 0xFA, 0x0D, 0x20, 0x5D, 0x07, 0x20, 0xAB, 0x0D, 0x0A, 0xC8,
  0x15, 0x0A, 0xE0, 0x72, 0x81, 0xAF, 0xC2, 0x0D, 0xB8, 0x1A, 0x0D, 0xF0, 0x72, 0x07, 0x20, 0x5C,
  0x81, 0xD0, 0xEC, 0x07, 0x0B, 0xA0, 0x73, 0x05, 0xD8, 0x1E, 0x0E, 0xB0, 0xD2, 0x0A, 0xA0, 0x72,
  0x09, 0xD8, 0x1E, 0x0D, 0xC0, 0x72, 0x08, 0xA0, 0x72, 0x0A, 0xC8, 0x1D, 0x0A, 0xD0, 0x72, 0x05,
  0xA0, 0x72, 0x0A, 0xB8, 0x1A, 0x05, 0xE8, 0x17, 0x05, 0xB0, 0x72, 0x0A, 0xA0, 0x52, 0x0D, 0xE0,
  0xED, 0x07, 0x20, 0xA0, 0xD3, 0x04, 0xFE, 0x07, 0x20, 0x24, 0x08, 0xFE, 0x07, 0x70, 0x8F, 0xE0,
  0x77, 0x04, 0x0D, 0xF9, 0x0D, 0x08, 0xA0, 0x67, 0x18, 0x65, 0xAD, 0xEF, 0xCA, 0x52, 0x81, 0x5F,
  0x97, 0x75, 0x01, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_unpublished() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 21, 22), Box(0, 0, 23, 23),
      ic_round_24_action_unpublished_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_update_disabled 24x24, 4-bit Alpha,  RLE, 149 bytes.
static const unsigned char ic_round_24_action_update_disabled_data[] PROGMEM = {
  0x10, 0x90, 0x64, 0x86, 0x39, 0xCF, 0xEC, 0x93, 0x50, 0x1A, 0x07, 0x20, 0x6F, 0x90, 0xB0, 0x22,
  0x81, 0x20, 0x5A, 0x07, 0x28, 0x92, 0x98, 0x31, 0x02, 0x7E, 0xFE, 0x37, 0x92, 0x05, 0xA0, 0x77,
  0x10, 0x10, 0xAC, 0x30, 0xCA, 0x07, 0x30, 0x0B, 0x40, 0xCB, 0x28, 0x13, 0xFE, 0xA0, 0x72, 0x0A,
  0x93, 0x07, 0xC2, 0x82, 0x9F, 0x75, 0xA0, 0x72, 0x0A, 0x20, 0x2C, 0x0E, 0x28, 0x3D, 0xF3, 0x05,
  0xA0, 0x77, 0x5A, 0x30, 0x5A, 0x07, 0x74, 0x0E, 0x94, 0x05, 0xA0, 0x77, 0x38, 0x1D, 0xF2, 0x40,
  0x5A, 0x07, 0x48, 0x11, 0xD7, 0x28, 0x19, 0xF8, 0x50, 0x5A, 0x07, 0x38, 0x18, 0xF9, 0x28, 0x24,
  0xFE, 0x15, 0x05, 0xA0, 0x72, 0x81, 0x9F, 0x43, 0x81, 0xBF, 0xA6, 0x05, 0xA0, 0x72, 0x07, 0x48,
  0x32, 0xEF, 0xA1, 0x50, 0x5A, 0x07, 0x78, 0x43, 0xEF, 0xE8, 0x32, 0x81, 0x37, 0xEA, 0x07, 0x70,
  0x20, 0xBF, 0x90, 0xCA, 0x07, 0x71, 0x89, 0x04, 0x9D, 0xEF, 0xD9, 0x40, 0x5A, 0x06, 0x77, 0x38,
  0x15, 0xF9, 0x77, 0x40, 0x11,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_update_disabled() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 20, 22), Box(0, 0, 23, 23),
      ic_round_24_action_update_disabled_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_update 24x24, 4-bit Alpha,  RLE, 123 bytes.
static const unsigned char ic_round_24_action_update_data[] PROGMEM = {
  0x58, 0x63, 0x9C, 0xFD, 0xC9, 0x34, 0x02, 0x30, 0x20, 0xBF, 0x98, 0x2B, 0x20, 0x79, 0x28, 0x43,
  0xEF, 0xE7, 0x22, 0x84, 0x27, 0xEF, 0xE9, 0xA1, 0x82, 0x2E, 0xFA, 0x71, 0x0A, 0xC1, 0x81, 0xBF,
  0xA7, 0x20, 0x7C, 0x81, 0x3F, 0xE5, 0x0C, 0x05, 0x20, 0x7D, 0x81, 0x9F, 0x75, 0x98, 0x17, 0x02,
  0xD8, 0x2E, 0xDF, 0x25, 0x90, 0x77, 0x10, 0xE9, 0x69, 0x07, 0x71, 0x0E, 0x96, 0x81, 0xED, 0x45,
  0x83, 0xCA, 0xCF, 0x35, 0x83, 0x4D, 0xFA, 0x12, 0x84, 0x2F, 0xD9, 0xF7, 0x78, 0x17, 0xE9, 0x28,
  0x57, 0xF9, 0x3F, 0xE1, 0x70, 0x01, 0x28, 0x5E, 0xF3, 0x0B, 0xFB, 0x73, 0x81, 0xAF, 0xB2, 0x83,
  0x1E, 0xFB, 0x17, 0x82, 0xAF, 0xE2, 0x38, 0x43, 0xEF, 0xE7, 0x22, 0x84, 0x27, 0xEF, 0xE3, 0x50,
  0x20, 0xBF, 0x90, 0xB0, 0x27, 0x18, 0x63, 0x9D, 0xEE, 0xD9, 0x45,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_update() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_update_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_upgrade 24x24, 4-bit Alpha,  RLE, 26 bytes.
static const unsigned char ic_round_24_action_upgrade_data[] PROGMEM = {
  0x30, 0x07, 0x50, 0x7A, 0x07, 0x30, 0x7C, 0x81, 0x70, 0x2E, 0x02, 0x3A, 0x6A, 0x6A, 0x6A, 0x6A,
  0x6A, 0x6A, 0x60, 0x0B, 0x77, 0x50, 0xBE, 0x00, 0xBE, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_upgrade() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(8, 4, 15, 19), Box(0, 0, 23, 23),
      ic_round_24_action_upgrade_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_verified 24x24, 4-bit Alpha,  RLE, 128 bytes.
static const unsigned char ic_round_24_action_verified_data[] PROGMEM = {
  0x70, 0x30, 0x14, 0x01, 0x03, 0x76, 0x89, 0x01, 0xEF, 0xA3, 0x3A, 0xFE, 0x17, 0x50, 0x9F, 0x90,
  0x97, 0x40, 0x4F, 0xB0, 0x47, 0x08, 0x0C, 0xFF, 0x0C, 0x07, 0x40, 0xCF, 0xFA, 0x0C, 0x40, 0xBF,
  0xFA, 0x0B, 0x40, 0x9F, 0xC0, 0x70, 0x9B, 0x09, 0x40, 0xCF, 0xB8, 0x15, 0x01, 0xB0, 0xC3, 0x0A,
  0xFB, 0x05, 0x20, 0xAC, 0x81, 0xA0, 0x8D, 0x0E, 0xC0, 0x52, 0x0A, 0xE0, 0x08, 0xC8, 0x4D, 0x03,
  0xEF, 0x52, 0x0A, 0xF8, 0x18, 0x0A, 0xB8, 0x3E, 0x10, 0x35, 0x20, 0xAF, 0x0A, 0x30, 0xCB, 0x0C,
  0x01, 0x30, 0xAF, 0x0C, 0x40, 0x9C, 0x82, 0xC1, 0x0A, 0xF9, 0x09, 0x40, 0xBD, 0x0E, 0x0D, 0xFA,
  0x0B, 0x40, 0xCF, 0xFA, 0x0C, 0x40, 0x70, 0xCF, 0xF0, 0xC0, 0x77, 0x04, 0xFB, 0x04, 0x74, 0x09,
  0xF9, 0x09, 0x75, 0x89, 0x01, 0xEF, 0xA3, 0x3A, 0xFE, 0x17, 0x60, 0x30, 0x14, 0x01, 0x03, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_verified() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_verified_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_verified_user 24x24, 4-bit Alpha,  RLE, 101 bytes.
static const unsigned char ic_round_24_action_verified_user_data[] PROGMEM = {
  0x78, 0x25, 0xAA, 0x57, 0x50, 0x60, 0xDC, 0x0D, 0x06, 0x78, 0x11, 0x8E, 0xF9, 0x81, 0xE8, 0x12,
  0x01, 0x0A, 0xFF, 0x81, 0xA1, 0xCF, 0xFA, 0x0C, 0x80, 0xD4, 0xF8, 0x1A, 0x1A, 0xFF, 0x0A, 0x20,
  0xAF, 0xE0, 0xA2, 0x07, 0xC0, 0xEF, 0x90, 0xA2, 0x07, 0xC0, 0xE0, 0xDA, 0x81, 0xA1, 0xAA, 0x0A,
  0x20, 0x7D, 0x0D, 0x0B, 0xA0, 0x92, 0x00, 0xA2, 0x07, 0xE0, 0xB0, 0x7B, 0x07, 0x40, 0x7F, 0x07,
  0x02, 0xC0, 0x72, 0x07, 0xF9, 0x81, 0x20, 0xAC, 0x00, 0xAF, 0x90, 0xA2, 0x02, 0xFF, 0x02, 0x30,
  0x7F, 0xD0, 0x75, 0x0A, 0xFB, 0x0A, 0x70, 0x9F, 0x90, 0x97, 0x20, 0x60, 0xEC, 0x0E, 0x06, 0x74,
  0x84, 0x17, 0xCC, 0x71, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_verified_user() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 1, 20, 22), Box(0, 0, 23, 23),
      ic_round_24_action_verified_user_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_vertical_split 24x24, 4-bit Alpha,  RLE, 47 bytes.
static const unsigned char ic_round_24_action_vertical_split_data[] PROGMEM = {
  0x0B, 0xE0, 0xB2, 0x0B, 0xE0, 0x0B, 0xE0, 0xB2, 0xF9, 0x73, 0xF9, 0x73, 0xF9, 0x0B, 0xE0, 0xB2,
  0xF9, 0x0B, 0xE0, 0xB2, 0xF9, 0x73, 0xF9, 0x73, 0xF9, 0x0B, 0xE0, 0xB2, 0xF9, 0x0B, 0xE0, 0xB2,
  0xF9, 0x73, 0xF9, 0x73, 0xF9, 0x0B, 0xE0, 0xB2, 0xF9, 0x0B, 0xE0, 0xB2, 0x0B, 0xE0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_vertical_split() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 5, 20, 18), Box(0, 0, 23, 23),
      ic_round_24_action_vertical_split_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_agenda 24x24, 4-bit Alpha,  RLE, 41 bytes.
static const unsigned char ic_round_24_action_view_agenda_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0x98, 0x4F, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D,
  0xFF, 0x0D, 0x04, 0x80, 0xC0, 0x00, 0x40, 0xDF, 0xF8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD8, 0x09, 0x84,
  0xF0, 0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xF0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_agenda() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_view_agenda_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_array 24x24, 4-bit Alpha,  RLE, 47 bytes.
static const unsigned char ic_round_24_action_view_array_data[] PROGMEM = {
  0x83, 0xBF, 0xB0, 0xBF, 0x98, 0x3B, 0x0B, 0xFB, 0xB1, 0xFB, 0x1E, 0x1F, 0xB1, 0xE1, 0xFB, 0x1E,
  0x1F, 0xB1, 0xE1, 0xFB, 0x1E, 0x1F, 0xB1, 0xE1, 0xFB, 0x1E, 0x1F, 0xB1, 0xE1, 0xFB, 0x1E, 0x1F,
  0xB1, 0xE1, 0xFB, 0x1E, 0x1F, 0xB1, 0xB8, 0x3B, 0xFB, 0x0B, 0xF9, 0x83, 0xB0, 0xBF, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_array() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 5, 20, 18), Box(0, 0, 23, 23),
      ic_round_24_action_view_array_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_carousel 24x24, 4-bit Alpha,  RLE, 50 bytes.
static const unsigned char ic_round_24_action_view_carousel_data[] PROGMEM = {
  0x50, 0xBF, 0x90, 0xB7, 0x3F, 0xB5, 0x0B, 0xA0, 0xB1, 0xFB, 0x10, 0xBA, 0x0B, 0xC1, 0xFB, 0x1F,
  0x91, 0xFB, 0x1F, 0x91, 0xFB, 0x1F, 0x91, 0xFB, 0x1F, 0x91, 0xFB, 0x1F, 0x91, 0xFB, 0x1F, 0x91,
  0xFB, 0x1F, 0x91, 0xFB, 0x1C, 0x0B, 0xA0, 0xB1, 0xFB, 0x10, 0xBA, 0x0B, 0x5F, 0xB7, 0x30, 0xBF,
  0x90, 0xB5,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_carousel() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 5, 21, 18), Box(0, 0, 23, 23),
      ic_round_24_action_view_carousel_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_column 24x24, 4-bit Alpha,  RLE, 83 bytes.
static const unsigned char ic_round_24_action_view_column_data[] PROGMEM = {
  0x0B, 0xB8, 0x1E, 0x26, 0xC8, 0x16, 0x2E, 0xB0, 0xBD, 0x05, 0x0A, 0xC0, 0xA0, 0x5F, 0xB0, 0x50,
  0xAC, 0x0A, 0x05, 0xFB, 0x05, 0x0A, 0xC0, 0xA0, 0x5F, 0xB0, 0x50, 0xAC, 0x0A, 0x05, 0xFB, 0x05,
  0x0A, 0xC0, 0xA0, 0x5F, 0xB0, 0x50, 0xAC, 0x0A, 0x05, 0xFB, 0x05, 0x0A, 0xC0, 0xA0, 0x5F, 0xB0,
  0x50, 0xAC, 0x0A, 0x05, 0xFB, 0x05, 0x0A, 0xC0, 0xA0, 0x5F, 0xB0, 0x50, 0xAC, 0x0A, 0x05, 0xFB,
  0x05, 0x0A, 0xC0, 0xA0, 0x5F, 0xB0, 0x50, 0xAC, 0x0A, 0x05, 0xD0, 0xBB, 0x81, 0xE2, 0x6C, 0x81,
  0x62, 0xEB, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_column() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 5, 20, 18), Box(0, 0, 23, 23),
      ic_round_24_action_view_column_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_comfy_alt 24x24, 4-bit Alpha,  RLE, 58 bytes.
static const unsigned char ic_round_24_action_view_comfy_alt_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDF, 0xFF, 0xC0, 0x12, 0x01, 0xA0, 0x12, 0x01,
  0xFB, 0x4A, 0x4F, 0xB4, 0xA4, 0xFB, 0x01, 0x20, 0x1A, 0x01, 0x20, 0x18, 0x0D, 0x6F, 0x01, 0x20,
  0x1A, 0x01, 0x20, 0x1F, 0xB4, 0xA4, 0xFB, 0x4A, 0x4F, 0xB0, 0x12, 0x01, 0xA0, 0x12, 0x01, 0xFF,
  0xFC, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_comfy_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_view_comfy_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_compact_alt 24x24, 4-bit Alpha,  RLE, 83 bytes.
static const unsigned char ic_round_24_action_view_compact_alt_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDF, 0xFF, 0xC8, 0x90, 0xC7, 0x77, 0xCC, 0x77,
  0x7C, 0xFB, 0x07, 0x30, 0x07, 0x30, 0x7F, 0xB0, 0x73, 0x00, 0x73, 0x07, 0xFB, 0x07, 0x30, 0x07,
  0x30, 0x7F, 0xB8, 0x90, 0xC7, 0x77, 0xCC, 0x77, 0x7C, 0xFB, 0x89, 0x0C, 0x77, 0x7C, 0xC7, 0x77,
  0xCF, 0xB0, 0x73, 0x00, 0x73, 0x07, 0xFB, 0x07, 0x30, 0x07, 0x30, 0x7F, 0xB0, 0x73, 0x00, 0x73,
  0x07, 0xFB, 0x89, 0x0C, 0x77, 0x7C, 0xC7, 0x77, 0xCF, 0xFF, 0xC0, 0xDF, 0xFC, 0x81, 0xD4, 0xDF,
  0xFA, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_compact_alt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_view_compact_alt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_cozy 24x24, 4-bit Alpha,  RLE, 81 bytes.
static const unsigned char ic_round_24_action_view_cozy_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDF, 0xFF, 0xC8, 0x90, 0x73, 0x34, 0xDD, 0x43,
  0x37, 0xFB, 0x03, 0x30, 0x0B, 0x30, 0x3F, 0xB0, 0x33, 0x00, 0xB3, 0x03, 0xFB, 0x04, 0x30, 0x0B,
  0x30, 0x4F, 0xB0, 0xD0, 0xFB, 0xA0, 0xFB, 0x0D, 0xFB, 0x0D, 0x0F, 0xBA, 0x0F, 0xB0, 0xDF, 0xB0,
  0x43, 0x00, 0xB3, 0x04, 0xFB, 0x03, 0x30, 0x0B, 0x30, 0x3F, 0xB0, 0x33, 0x00, 0xB3, 0x03, 0xFB,
  0x89, 0x07, 0x33, 0x4D, 0xD4, 0x33, 0x7F, 0xFF, 0xC0, 0xDF, 0xFC, 0x81, 0xD4, 0xDF, 0xFA, 0x0D,
  0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_cozy() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_view_cozy_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_day 24x24, 4-bit Alpha,  RLE, 32 bytes.
static const unsigned char ic_round_24_action_view_day_data[] PROGMEM = {
  0x0B, 0xFF, 0xB0, 0xBF, 0xFD, 0x0B, 0xFF, 0xB0, 0xB8, 0x0C, 0x20, 0x0B, 0xFF, 0xB0, 0xB8, 0x09,
  0xD6, 0xF0, 0xBF, 0xFB, 0x0B, 0x80, 0xC2, 0x00, 0xBF, 0xFB, 0x0B, 0xFF, 0xD0, 0xBF, 0xFB, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_day() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_view_day_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_headline 24x24, 4-bit Alpha,  RLE, 30 bytes.
static const unsigned char ic_round_24_action_view_headline_data[] PROGMEM = {
  0x0B, 0xFF, 0x00, 0xBF, 0xF0, 0xB7, 0x77, 0x74, 0x0B, 0xFF, 0x00, 0xBF, 0xF0, 0xB7, 0x77, 0x74,
  0x0B, 0xFF, 0x00, 0xBF, 0xF0, 0xB7, 0x77, 0x74, 0x0B, 0xFF, 0x00, 0xBF, 0xF0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_headline() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 5, 19, 18), Box(0, 0, 23, 23),
      ic_round_24_action_view_headline_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_in_ar 24x24, 4-bit Alpha,  RLE, 150 bytes.
static const unsigned char ic_round_24_action_view_in_ar_data[] PROGMEM = {
  0x18, 0x28, 0xDF, 0xB7, 0x58, 0x4B, 0xFD, 0x80, 0x8B, 0x0B, 0x75, 0x0B, 0xB8, 0x28, 0xDF, 0x37,
  0x72, 0x81, 0x3F, 0xDA, 0x78, 0x23, 0x99, 0x37, 0xA0, 0x0B, 0x50, 0x10, 0x9C, 0x09, 0x01, 0x50,
  0x0B, 0x60, 0x70, 0xEA, 0x00, 0x8A, 0x0E, 0x07, 0x73, 0x02, 0x0D, 0xA0, 0xA0, 0x22, 0x02, 0x0A,
  0xA0, 0xD0, 0x27, 0x10, 0xCA, 0x07, 0x60, 0x7A, 0x0C, 0x71, 0xC0, 0x90, 0x12, 0x01, 0x09, 0xC7,
  0x1A, 0x08, 0xA8, 0x2E, 0x77, 0xEA, 0x08, 0xA7, 0x1A, 0x10, 0x20, 0xAC, 0x0A, 0x02, 0x1A, 0x71,
  0xA3, 0x04, 0xA0, 0x43, 0xA7, 0x1A, 0x4A, 0x4A, 0x71, 0xA4, 0xA4, 0xA7, 0x18, 0x2C, 0xFC, 0x42,
  0xA2, 0x82, 0x4C, 0xFC, 0x71, 0x02, 0x0D, 0xA0, 0xA0, 0x2A, 0x02, 0x0A, 0xA0, 0xD0, 0x27, 0x30,
  0x70, 0xEE, 0x0E, 0x07, 0x60, 0x0B, 0x50, 0x10, 0x9C, 0x09, 0x01, 0x50, 0x0B, 0xA7, 0x82, 0x39,
  0x93, 0x7A, 0x81, 0xDF, 0x37, 0x72, 0x82, 0x3F, 0xD8, 0xB0, 0xB7, 0x50, 0xBB, 0x84, 0x80, 0x8D,
  0xFB, 0x75, 0x82, 0xBF, 0xD8, 0x10,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_in_ar() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 1, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_view_in_ar_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_kanban 24x24, 4-bit Alpha,  RLE, 55 bytes.
static const unsigned char ic_round_24_action_view_kanban_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xC4, 0xF0, 0x03, 0xA0, 0x03, 0xA0, 0x03,
  0xF9, 0x2A, 0x2A, 0x2F, 0x92, 0xA2, 0xA2, 0xF9, 0x2A, 0x2A, 0x2F, 0x92, 0xA0, 0x03, 0xA2, 0xF9,
  0x2E, 0x2F, 0x92, 0xE2, 0xF9, 0x2E, 0x00, 0x3F, 0x92, 0xFF, 0xA0, 0x03, 0x80, 0xD4, 0xF0, 0xDF,
  0xFA, 0x81, 0xD4, 0xDF, 0xF0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_kanban() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_view_kanban_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_list 24x24, 4-bit Alpha,  RLE, 51 bytes.
static const unsigned char ic_round_24_action_view_list_data[] PROGMEM = {
  0x0B, 0xA8, 0x1B, 0x0B, 0xFC, 0x0B, 0xC1, 0xFF, 0xB1, 0xFE, 0x0B, 0xA8, 0x1B, 0x0B, 0xFC, 0x0B,
  0x77, 0x40, 0xBA, 0x81, 0xB0, 0xBF, 0xC0, 0xBC, 0x1F, 0xFB, 0x1F, 0xE0, 0xBA, 0x81, 0xB0, 0xBF,
  0xC0, 0xB7, 0x74, 0x0B, 0xA8, 0x1B, 0x0B, 0xFC, 0x0B, 0xC1, 0xFF, 0xB1, 0xFE, 0x0B, 0xA8, 0x1B,
  0x0B, 0xFC, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_list() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 5, 20, 18), Box(0, 0, 23, 23),
      ic_round_24_action_view_list_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_module 24x24, 4-bit Alpha,  RLE, 92 bytes.
static const unsigned char ic_round_24_action_view_module_data[] PROGMEM = {
  0x0B, 0xB8, 0x1E, 0x26, 0xC8, 0x16, 0x2E, 0xB0, 0xBD, 0x05, 0x0A, 0xC0, 0xA0, 0x5F, 0xB0, 0x50,
  0xAC, 0x0A, 0x05, 0xFB, 0x05, 0x0A, 0xC0, 0xA0, 0x5F, 0xB0, 0x50, 0xAC, 0x0A, 0x05, 0xFB, 0x04,
  0x09, 0xC0, 0x90, 0x4D, 0x8C, 0x24, 0x77, 0x76, 0x02, 0x77, 0x77, 0x20, 0x67, 0x77, 0x44, 0x77,
  0x76, 0x02, 0x77, 0x77, 0x20, 0x67, 0x77, 0x4D, 0x04, 0x09, 0xC0, 0x90, 0x4F, 0xB0, 0x50, 0xAC,
  0x0A, 0x05, 0xFB, 0x05, 0x0A, 0xC0, 0xA0, 0x5F, 0xB0, 0x50, 0xAC, 0x0A, 0x05, 0xFB, 0x05, 0x0A,
  0xC0, 0xA0, 0x5D, 0x0B, 0xB8, 0x1E, 0x26, 0xC8, 0x16, 0x2E, 0xB0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_module() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 5, 20, 18), Box(0, 0, 23, 23),
      ic_round_24_action_view_module_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_quilt 24x24, 4-bit Alpha,  RLE, 74 bytes.
static const unsigned char ic_round_24_action_view_quilt_data[] PROGMEM = {
  0x0B, 0xB8, 0x1E, 0x26, 0xFB, 0x0B, 0xD0, 0x50, 0xAF, 0xFA, 0x05, 0x0A, 0xFF, 0xA0, 0x50, 0xAF,
  0xFA, 0x05, 0x0A, 0xFF, 0xA0, 0x50, 0x9F, 0xFA, 0x05, 0x02, 0x80, 0x67, 0x04, 0xD8, 0x93, 0x52,
  0x77, 0x77, 0x20, 0x67, 0x77, 0x4D, 0x05, 0x09, 0xC0, 0x90, 0x4F, 0xB0, 0x50, 0xAC, 0x0A, 0x05,
  0xFB, 0x05, 0x0A, 0xC0, 0xA0, 0x5F, 0xB0, 0x50, 0xAC, 0x0A, 0x05, 0xFB, 0x05, 0x0A, 0xC0, 0xA0,
  0x5D, 0x0B, 0xB8, 0x1E, 0x26, 0xC8, 0x16, 0x2E, 0xB0, 0xB0,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_quilt() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 5, 20, 18), Box(0, 0, 23, 23),
      ic_round_24_action_view_quilt_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_sidebar 24x24, 4-bit Alpha,  RLE, 46 bytes.
static const unsigned char ic_round_24_action_view_sidebar_data[] PROGMEM = {
  0x0B, 0xFD, 0x0B, 0x20, 0xBA, 0x0B, 0xFF, 0x2F, 0xFC, 0x2F, 0xFC, 0x20, 0xBA, 0x0B, 0xFF, 0x6F,
  0xF6, 0xFF, 0x20, 0xBA, 0x0B, 0xFF, 0x2F, 0xFC, 0x2F, 0xFC, 0x20, 0xBA, 0x0B, 0xFF, 0x6F, 0xF6,
  0xFF, 0x20, 0xBA, 0x0B, 0xFF, 0x2F, 0xFC, 0x2C, 0x0B, 0xFD, 0x0B, 0x20, 0xBA, 0x0B,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_sidebar() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_view_sidebar_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_stream 24x24, 4-bit Alpha,  RLE, 40 bytes.
static const unsigned char ic_round_24_action_view_stream_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xC0, 0xF0, 0xDF, 0xFA, 0x81, 0xD4, 0xDF,
  0xF0, 0xD0, 0x48, 0x0C, 0x00, 0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xC0, 0xF0,
  0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xF0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_stream() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 5, 20, 18), Box(0, 0, 23, 23),
      ic_round_24_action_view_stream_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_timeline 24x24, 4-bit Alpha,  RLE, 44 bytes.
static const unsigned char ic_round_24_action_view_timeline_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xD1, 0xF0, 0x34, 0x03, 0xFD, 0x03, 0x40,
  0x38, 0x0D, 0x1F, 0x03, 0x40, 0x3F, 0xD0, 0x34, 0x03, 0x80, 0xD1, 0xF0, 0x34, 0x03, 0xFD, 0x03,
  0x40, 0x38, 0x0D, 0x1F, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_timeline() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_view_timeline_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_view_week 24x24, 4-bit Alpha,  RLE, 119 bytes.
static const unsigned char ic_round_24_action_view_week_data[] PROGMEM = {
  0x83, 0x4D, 0xFE, 0x82, 0x01, 0x0B, 0xA0, 0xB0, 0x12, 0x84, 0x8E, 0xFD, 0x4D, 0xC8, 0x13, 0x08,
  0xC8, 0x18, 0x03, 0xC0, 0xDD, 0x81, 0x50, 0xAC, 0x81, 0xA0, 0x5F, 0xB8, 0x15, 0x0A, 0xC8, 0x1A,
  0x05, 0xFB, 0x81, 0x50, 0xAC, 0x81, 0xA0, 0x5F, 0xB8, 0x15, 0x0A, 0xC8, 0x1A, 0x05, 0xFB, 0x81,
  0x50, 0xAC, 0x81, 0xA0, 0x5F, 0xB8, 0x15, 0x0A, 0xC8, 0x1A, 0x05, 0xFB, 0x81, 0x50, 0xAC, 0x81,
  0xA0, 0x5F, 0xB8, 0x15, 0x0A, 0xC8, 0x1A, 0x05, 0xFB, 0x81, 0x50, 0xAC, 0x81, 0xA0, 0x5F, 0xB8,
  0x15, 0x0A, 0xC8, 0x1A, 0x05, 0xFB, 0x81, 0x50, 0xAC, 0x81, 0xA0, 0x5F, 0xB8, 0x15, 0x0A, 0xC8,
  0x1A, 0x05, 0xD0, 0xDC, 0x81, 0x30, 0x8C, 0x81, 0x80, 0x3C, 0x84, 0xD4, 0xDF, 0xE8, 0x20, 0x10,
  0xBA, 0x0B, 0x01, 0x28, 0x38, 0xEF, 0xD4,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_view_week() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_view_week_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_visibility_off 24x24, 4-bit Alpha,  RLE, 142 bytes.
static const unsigned char ic_round_24_action_visibility_off_data[] PROGMEM = {
  0x18, 0x16, 0xF7, 0x77, 0x50, 0x4A, 0x07, 0x28, 0x13, 0xAD, 0xA8, 0x2D, 0xA7, 0x17, 0x10, 0x5A,
  0x07, 0x20, 0xAF, 0x09, 0x01, 0x70, 0x9A, 0x07, 0x28, 0x29, 0x88, 0xBC, 0x0E, 0x04, 0x50, 0x5C,
  0x07, 0x50, 0x30, 0xDC, 0x05, 0x30, 0x4E, 0x07, 0x28, 0x32, 0x10, 0x1E, 0xC0, 0x42, 0x0D, 0xC0,
  0xBA, 0x07, 0x28, 0x29, 0x30, 0x6C, 0x81, 0xD1, 0x8D, 0x02, 0x05, 0xA0, 0x72, 0x81, 0x70, 0x1D,
  0x08, 0x0D, 0xD2, 0x0E, 0xA0, 0x74, 0xD0, 0xD0, 0x8D, 0x81, 0x10, 0xBB, 0x07, 0x20, 0x2D, 0x81,
  0x80, 0xDC, 0x82, 0x60, 0x3E, 0xB0, 0x72, 0x0A, 0xB0, 0xD2, 0x04, 0xC8, 0x4E, 0x10, 0x16, 0x8A,
  0x07, 0x20, 0xAA, 0x03, 0x30, 0x5C, 0x0D, 0x03, 0x30, 0x5A, 0x07, 0x20, 0xA0, 0x55, 0x04, 0x0E,
  0xC8, 0x2B, 0x88, 0xBB, 0x07, 0x72, 0x01, 0x09, 0xFC, 0x07, 0x73, 0x89, 0x01, 0x7A, 0xDF, 0xED,
  0xA6, 0x6A, 0x07, 0x77, 0x50, 0x5A, 0x05, 0x77, 0x58, 0x15, 0xF9, 0x77, 0x60, 0x13,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_visibility_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 3, 22, 21), Box(0, 0, 23, 23),
      ic_round_24_action_visibility_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_visibility 24x24, 4-bit Alpha,  RLE, 124 bytes.
static const unsigned char ic_round_24_action_visibility_data[] PROGMEM = {
  0x68, 0x21, 0x7A, 0xDA, 0x82, 0xDA, 0x71, 0x73, 0x01, 0x09, 0xFB, 0x09, 0x01, 0x70, 0x40, 0xEC,
  0x82, 0xB8, 0x8B, 0xC0, 0xE0, 0x45, 0x05, 0xC0, 0xD0, 0x34, 0x03, 0x0D, 0xC0, 0x53, 0x04, 0xC8,
  0x90, 0xE1, 0x01, 0x66, 0x10, 0x1E, 0xC0, 0x42, 0x0D, 0xC8, 0x26, 0x03, 0xEA, 0x82, 0xE3, 0x06,
  0xC8, 0x1D, 0x08, 0xD8, 0x11, 0x0B, 0xC8, 0x1B, 0x01, 0xD0, 0x80, 0xDD, 0x20, 0xEC, 0x0E, 0x2D,
  0x0D, 0x08, 0xD8, 0x11, 0x0B, 0xC8, 0x1B, 0x01, 0xD8, 0x18, 0x0D, 0xC8, 0x26, 0x03, 0xEA, 0x82,
  0xE3, 0x06, 0xC0, 0xD2, 0x04, 0xC8, 0x90, 0xE1, 0x01, 0x66, 0x10, 0x1E, 0xC0, 0x43, 0x05, 0xC0,
  0xD0, 0x34, 0x03, 0x0D, 0xC0, 0x55, 0x04, 0x0E, 0xC8, 0x2B, 0x88, 0xBC, 0x0E, 0x04, 0x70, 0x10,
  0x9F, 0xB0, 0x90, 0x17, 0x38, 0x21, 0x7A, 0xDA, 0x82, 0xDA, 0x71, 0x60,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_visibility() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 4, 22, 18), Box(0, 0, 23, 23),
      ic_round_24_action_visibility_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_voice_over_off 24x24, 4-bit Alpha,  RLE, 151 bytes.
static const unsigned char ic_round_24_action_voice_over_off_data[] PROGMEM = {
  0x77, 0x40, 0x30, 0x44, 0x81, 0x29, 0x27, 0x50, 0x1A, 0x03, 0x38, 0x27, 0xFD, 0x27, 0x58, 0x1D,
  0xFD, 0x48, 0x6B, 0xFD, 0x20, 0x18, 0x17, 0x05, 0xA0, 0x44, 0x86, 0xBF, 0xD2, 0x02, 0xD1, 0x28,
  0x14, 0xD7, 0x28, 0x1D, 0xF9, 0x40, 0xAA, 0x83, 0xD2, 0x02, 0x82, 0x81, 0x8F, 0xE2, 0x81, 0xAF,
  0xD4, 0x0E, 0xB8, 0x2D, 0x20, 0x12, 0x05, 0xA8, 0x33, 0x08, 0xFE, 0x40, 0xEC, 0x0D, 0x02, 0x30,
  0x5A, 0x83, 0x30, 0x8F, 0xE4, 0x0A, 0xD0, 0xD0, 0x22, 0x07, 0xA2, 0x81, 0xBF, 0xD4, 0x02, 0x0E,
  0xD8, 0x4D, 0x20, 0x2B, 0x62, 0x81, 0xEF, 0xA5, 0x87, 0x2A, 0xEE, 0xAB, 0xFD, 0x24, 0x06, 0xA0,
  0x57, 0x48, 0x2B, 0xFD, 0x23, 0x81, 0xDF, 0xD7, 0x68, 0x2B, 0xFD, 0x22, 0x81, 0xDF, 0x44, 0x89,
  0x72, 0x6A, 0xDE, 0xFD, 0xA7, 0x2B, 0xFD, 0x20, 0x12, 0x30, 0x30, 0xBF, 0xB8, 0x3B, 0xEF, 0xD2,
  0x40, 0x4F, 0xFA, 0x0D, 0x02, 0x30, 0xDF, 0xF8, 0x3D, 0xBF, 0xD2, 0x2F, 0xFA, 0x18, 0x1B, 0xF9,
  0x20, 0xBF, 0xF0, 0xB2, 0x07, 0x02, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_voice_over_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(1, 2, 22, 20), Box(0, 0, 23, 23),
      ic_round_24_action_voice_over_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_watch_later 24x24, 4-bit Alpha,  RLE, 103 bytes.
static const unsigned char ic_round_24_action_watch_later_data[] PROGMEM = {
  0x68, 0x65, 0x9D, 0xEE, 0xD9, 0x57, 0x30, 0x40, 0xDF, 0x90, 0xD0, 0x47, 0x08, 0xFD, 0x08, 0x50,
  0x8F, 0xF0, 0x83, 0x04, 0xFF, 0xA0, 0x42, 0x0D, 0xF0, 0x20, 0xAF, 0x81, 0xD0, 0x5F, 0x91, 0x07,
  0xF9, 0x05, 0x09, 0xF9, 0x10, 0x7F, 0x90, 0x90, 0xDF, 0x91, 0x07, 0xF9, 0x0D, 0x0E, 0xF9, 0x10,
  0x7F, 0x90, 0x0E, 0xF9, 0x10, 0x20, 0xCF, 0x0E, 0x0D, 0xF9, 0x83, 0xB1, 0x06, 0xED, 0x0D, 0x09,
  0xFA, 0x83, 0xE7, 0x01, 0xBC, 0x09, 0x05, 0xFC, 0x81, 0xC4, 0x8C, 0x81, 0x50, 0xDF, 0xFA, 0x0D,
  0x20, 0x4F, 0xFA, 0x04, 0x30, 0x8F, 0xF0, 0x85, 0x08, 0xFD, 0x08, 0x70, 0x40, 0xDF, 0x90, 0xD0,
  0x47, 0x38, 0x65, 0x9D, 0xEE, 0xD9, 0x56,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_watch_later() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 21), Box(0, 0, 23, 23),
      ic_round_24_action_watch_later_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_webhook 24x24, 4-bit Alpha,  RLE, 149 bytes.
static const unsigned char ic_round_24_action_webhook_data[] PROGMEM = {
  0x78, 0x41, 0x8D, 0xFC, 0x87, 0x60, 0x20, 0xDD, 0x0D, 0x01, 0x74, 0x87, 0xCF, 0xC3, 0x03, 0xCF,
  0xB7, 0x38, 0x91, 0x3F, 0xD1, 0x27, 0x20, 0xDF, 0x37, 0x28, 0x91, 0x6F, 0x90, 0xDF, 0xD0, 0x6E,
  0x27, 0x28, 0x36, 0xF8, 0x0D, 0xA0, 0x17, 0x58, 0x63, 0xFD, 0x02, 0xCF, 0x97, 0x68, 0x3C, 0xFB,
  0x02, 0xA0, 0x37, 0x50, 0x2A, 0x83, 0x50, 0x8F, 0xC7, 0x10, 0x40, 0x32, 0x81, 0x7F, 0xD3, 0x0D,
  0xA8, 0x1E, 0xB4, 0x38, 0x67, 0xFE, 0x01, 0xEF, 0x43, 0x05, 0xD8, 0x18, 0x04, 0xA8, 0x35, 0x0A,
  0xFA, 0x58, 0x23, 0x11, 0x7A, 0x87, 0x4B, 0xF6, 0x06, 0xFE, 0x16, 0x89, 0x05, 0x50, 0x7F, 0xBE,
  0xF1, 0x5A, 0x81, 0x80, 0xBF, 0x86, 0x51, 0xFE, 0xEF, 0x15, 0xA0, 0x50, 0x1F, 0x98, 0x94, 0x51,
  0xFE, 0xBF, 0x70, 0x55, 0x07, 0xFA, 0x48, 0x55, 0x50, 0x7F, 0xB4, 0xA8, 0x27, 0x21, 0x7A, 0x04,
  0x28, 0x33, 0x51, 0x17, 0xA8, 0x14, 0x08, 0xE0, 0x73, 0x0D, 0xD0, 0x83, 0x84, 0x4B, 0xEE, 0xB3,
  0x48, 0x43, 0xBE, 0xEB, 0x42,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_webhook() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_webhook_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_width_full 24x24, 4-bit Alpha,  RLE, 48 bytes.
static const unsigned char ic_round_24_action_width_full_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDA, 0x1F, 0xF1, 0xC1, 0xFF, 0x1C, 0x1F, 0xF1,
  0xC1, 0xFF, 0x1C, 0x1F, 0xF1, 0xC1, 0xFF, 0x1C, 0x1F, 0xF1, 0xC1, 0xFF, 0x1C, 0x1F, 0xF1, 0xC1,
  0xFF, 0x1C, 0x1F, 0xF1, 0xC1, 0xFF, 0x1A, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_width_full() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_width_full_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_width_normal 24x24, 4-bit Alpha,  RLE, 48 bytes.
static const unsigned char ic_round_24_action_width_normal_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDA, 0x4F, 0x94, 0xC4, 0xF9, 0x4C, 0x4F, 0x94,
  0xC4, 0xF9, 0x4C, 0x4F, 0x94, 0xC4, 0xF9, 0x4C, 0x4F, 0x94, 0xC4, 0xF9, 0x4C, 0x4F, 0x94, 0xC4,
  0xF9, 0x4C, 0x4F, 0x94, 0xC4, 0xF9, 0x4A, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_width_normal() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_width_normal_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_width_wide 24x24, 4-bit Alpha,  RLE, 48 bytes.
static const unsigned char ic_round_24_action_width_wide_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDA, 0x2F, 0xD2, 0xC2, 0xFD, 0x2C, 0x2F, 0xD2,
  0xC2, 0xFD, 0x2C, 0x2F, 0xD2, 0xC2, 0xFD, 0x2C, 0x2F, 0xD2, 0xC2, 0xFD, 0x2C, 0x2F, 0xD2, 0xC2,
  0xFD, 0x2C, 0x2F, 0xD2, 0xC2, 0xFD, 0x2A, 0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_width_wide() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 4, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_width_wide_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_wifi_protected_setup 24x24, 4-bit Alpha,  RLE, 91 bytes.
static const unsigned char ic_round_24_action_wifi_protected_setup_data[] PROGMEM = {
  0x70, 0xEE, 0x02, 0x71, 0xE0, 0x77, 0x2D, 0x0D, 0x01, 0x40, 0x30, 0x63, 0xE0, 0xB3, 0x81, 0x1D,
  0x93, 0xF0, 0x62, 0x81, 0x8F, 0x73, 0xA0, 0xEC, 0x0D, 0x2A, 0x08, 0x39, 0x81, 0x71, 0xBC, 0x03,
  0x04, 0xA0, 0xA3, 0x02, 0x20, 0x10, 0xEB, 0x06, 0x07, 0xA0, 0xE7, 0x05, 0xB0, 0x08, 0xB0, 0x57,
  0x0E, 0xA0, 0x70, 0x6B, 0x0E, 0x01, 0x20, 0x23, 0x0A, 0xA0, 0x40, 0x3C, 0x81, 0xB1, 0x79, 0x30,
  0x8A, 0x20, 0xEC, 0x0E, 0xA3, 0x81, 0x7F, 0x82, 0x06, 0xF3, 0x81, 0x9D, 0x13, 0x0B, 0xE3, 0x06,
  0x03, 0x40, 0x10, 0xED, 0x72, 0x07, 0xE7, 0x10, 0x2E, 0x0E, 0x70,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_wifi_protected_setup() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(4, 3, 19, 20), Box(0, 0, 23, 23),
      ic_round_24_action_wifi_protected_setup_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_work_history 24x24, 4-bit Alpha,  RLE, 104 bytes.
static const unsigned char ic_round_24_action_work_history_data[] PROGMEM = {
  0x60, 0x40, 0xDC, 0x0D, 0x04, 0x76, 0x0D, 0xE0, 0xD7, 0x6A, 0x4A, 0x76, 0xA4, 0xA7, 0x04, 0x0D,
  0xFF, 0xA8, 0x2D, 0x40, 0xDF, 0xFC, 0x0D, 0x1F, 0xFE, 0x1F, 0xFE, 0x1F, 0xFE, 0x1F, 0xD8, 0x1E,
  0x72, 0x28, 0x12, 0x7E, 0x1F, 0xC0, 0xA7, 0x2F, 0xB0, 0xA2, 0x84, 0x4B, 0xEE, 0xB4, 0x2F, 0xA0,
  0xE2, 0x08, 0xE0, 0x81, 0xFA, 0x81, 0x70, 0x4B, 0x00, 0x7B, 0x04, 0xFA, 0x81, 0x20, 0xBB, 0x00,
  0x7B, 0x0B, 0xFA, 0x20, 0xEB, 0x00, 0x7B, 0x0E, 0xFA, 0x20, 0xEB, 0x81, 0xB1, 0xBA, 0x0E, 0x0D,
  0xF9, 0x81, 0x30, 0xBC, 0x85, 0xB1, 0xDF, 0xB4, 0xDF, 0x81, 0x70, 0x4D, 0x0D, 0xA0, 0x47, 0x50,
  0x8E, 0x08, 0x77, 0x84, 0x4B, 0xEE, 0xB4, 0x20,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_work_history() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_work_history_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_work_off 24x24, 4-bit Alpha,  RLE, 119 bytes.
static const unsigned char ic_round_24_action_work_off_data[] PROGMEM = {
  0x81, 0x3A, 0x23, 0x04, 0x0D, 0xC0, 0xD0, 0x47, 0x82, 0x7F, 0xE2, 0x20, 0xCE, 0x0D, 0x71, 0x85,
  0xBF, 0xE2, 0x02, 0xE4, 0xA7, 0x28, 0x4B, 0xFE, 0x20, 0x24, 0xA7, 0x04, 0x0D, 0xB8, 0x3E, 0x20,
  0x2E, 0xF9, 0x82, 0xD4, 0x0D, 0xD8, 0x3E, 0x20, 0x2E, 0xF9, 0x0D, 0x1F, 0x83, 0xE2, 0x02, 0xEF,
  0x91, 0xF9, 0x83, 0xE2, 0x02, 0xEF, 0x1F, 0xA8, 0x3E, 0x20, 0x2E, 0xE1, 0xFB, 0x83, 0xE2, 0x02,
  0xED, 0x1F, 0xC8, 0x3E, 0x20, 0x2E, 0xC1, 0xFD, 0x83, 0xE2, 0x02, 0xEB, 0x1F, 0xE8, 0x3E, 0x20,
  0x2E, 0xA1, 0xFF, 0x83, 0xE2, 0x02, 0xE9, 0x1F, 0xF9, 0x83, 0xE2, 0x02, 0xE1, 0xFF, 0xA8, 0x2E,
  0x20, 0x21, 0xFF, 0xB0, 0xE0, 0x22, 0x0D, 0xFF, 0xB8, 0x3E, 0x20, 0x4D, 0xFF, 0xB0, 0xD0, 0x27,
  0x74, 0x81, 0xBF, 0x97, 0x75, 0x07, 0x02,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_work_off() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 22, 22), Box(0, 0, 23, 23),
      ic_round_24_action_work_off_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_work_outline 24x24, 4-bit Alpha,  RLE, 57 bytes.
static const unsigned char ic_round_24_action_work_outline_data[] PROGMEM = {
  0x60, 0x40, 0xDC, 0x0D, 0x04, 0x75, 0x0D, 0xE0, 0xD7, 0x5A, 0x4A, 0x75, 0xA4, 0xA6, 0x04, 0x0D,
  0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xDA, 0x03, 0x77, 0x03, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72,
  0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC7, 0x72, 0xC0, 0x37, 0x70, 0x3A,
  0x0D, 0xFF, 0xC8, 0x1D, 0x4D, 0xFF, 0xA0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_work_outline() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_work_outline_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_work 24x24, 4-bit Alpha,  RLE, 34 bytes.
static const unsigned char ic_round_24_action_work_data[] PROGMEM = {
  0x60, 0x40, 0xDC, 0x0D, 0x04, 0x75, 0x0D, 0xE0, 0xD7, 0x5A, 0x4A, 0x75, 0xA4, 0xA6, 0x04, 0x0D,
  0xFF, 0xA8, 0x1D, 0x4D, 0xFF, 0xC0, 0xD8, 0x0B, 0xB0, 0xF0, 0xDF, 0xFC, 0x81, 0xD4, 0xDF, 0xFA,
  0x0D, 0x04,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_work() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 2, 21, 20), Box(0, 0, 23, 23),
      ic_round_24_action_work_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_wysiwyg 24x24, 4-bit Alpha,  RLE, 48 bytes.
static const unsigned char ic_round_24_action_wysiwyg_data[] PROGMEM = {
  0x04, 0x0D, 0xFF, 0x81, 0xD4, 0xDF, 0xFA, 0x0D, 0x80, 0xC2, 0xF7, 0x7C, 0x77, 0xC7, 0x7C, 0x20,
  0xBF, 0x90, 0xB2, 0xC2, 0x0B, 0xF9, 0x0B, 0x2C, 0x77, 0xC7, 0x7C, 0x20, 0xBC, 0x0B, 0x6C, 0x20,
  0xBC, 0x0B, 0x6C, 0x77, 0xC7, 0x7C, 0x77, 0xA0, 0xDF, 0xFA, 0x81, 0xD4, 0xDF, 0xF0, 0xD0, 0x40,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_wysiwyg() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 20, 20), Box(0, 0, 23, 23),
      ic_round_24_action_wysiwyg_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_youtube_searched_for 24x24, 4-bit Alpha,  RLE, 104 bytes.
static const unsigned char ic_round_24_action_youtube_searched_for_data[] PROGMEM = {
  0x68, 0x46, 0xCE, 0xEC, 0x67, 0x50, 0x20, 0xDE, 0x0D, 0x02, 0x72, 0x89, 0x21, 0xEF, 0xC5, 0x11,
  0x5D, 0xFE, 0x17, 0x18, 0x1A, 0xFB, 0x68, 0x1B, 0xFB, 0x78, 0x21, 0xFE, 0x16, 0x82, 0x1E, 0xF1,
  0x68, 0x15, 0xFB, 0x71, 0x81, 0xAF, 0x64, 0x86, 0x77, 0xBF, 0xC7, 0x71, 0x58, 0x18, 0xF7, 0x40,
  0xAD, 0x0D, 0x68, 0x1A, 0xF6, 0x50, 0x8B, 0x0C, 0x01, 0x58, 0x21, 0xEF, 0x26, 0x82, 0x5E, 0xC1,
  0x68, 0x1A, 0xFB, 0x71, 0x01, 0x38, 0x33, 0x11, 0x5C, 0xA0, 0x27, 0x40, 0x6D, 0x82, 0xDB, 0xF7,
  0x73, 0x86, 0x3C, 0xEE, 0xC7, 0x05, 0xA0, 0x77, 0x73, 0x07, 0xA0, 0x77, 0x73, 0x07, 0xA0, 0x77,
  0x73, 0x07, 0xA0, 0x57, 0x73, 0x81, 0x7F, 0x50,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_youtube_searched_for() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(2, 3, 21, 19), Box(0, 0, 23, 23),
      ic_round_24_action_youtube_searched_for_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_zoom_in 24x24, 4-bit Alpha,  RLE, 99 bytes.
static const unsigned char ic_round_24_action_zoom_in_data[] PROGMEM = {
  0x38, 0x53, 0xAD, 0xFD, 0x93, 0x72, 0x08, 0xF0, 0x87, 0x08, 0xA8, 0x38, 0x30, 0x38, 0xA0, 0x85,
  0x03, 0xA0, 0x35, 0x03, 0xA0, 0x34, 0x81, 0xAF, 0x83, 0x0D, 0x38, 0x18, 0xF9, 0x48, 0x1D, 0xF3,
  0x39, 0x38, 0x13, 0xFD, 0x40, 0xE9, 0x20, 0xDB, 0x0D, 0x2A, 0x48, 0x1D, 0xF3, 0x39, 0x38, 0x13,
  0xFD, 0x48, 0x19, 0xF8, 0x30, 0xD3, 0x81, 0x8F, 0xA4, 0x03, 0xA0, 0x35, 0x03, 0xA0, 0x35, 0x08,
  0xA8, 0x38, 0x30, 0x38, 0xA0, 0xA7, 0x08, 0xF8, 0x2A, 0xFD, 0x16, 0x89, 0x23, 0x9D, 0xFD, 0xA3,
  0x0D, 0xFD, 0x17, 0x68, 0x31, 0xDF, 0xD1, 0x76, 0x83, 0x1D, 0xFD, 0x17, 0x68, 0x21, 0xDF, 0xD7,
  0x78, 0x11, 0xDC,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_zoom_in() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 19, 19), Box(0, 0, 23, 23),
      ic_round_24_action_zoom_in_data, Alpha4(color::Black));
  return value;
}

// Image file ic_round_24_action_zoom_out 24x24, 4-bit Alpha,  RLE, 94 bytes.
static const unsigned char ic_round_24_action_zoom_out_data[] PROGMEM = {
  0x38, 0x53, 0xAD, 0xFD, 0x93, 0x72, 0x08, 0xF0, 0x87, 0x08, 0xA8, 0x38, 0x30, 0x38, 0xA0, 0x85,
  0x03, 0xA0, 0x35, 0x03, 0xA0, 0x34, 0x81, 0xAF, 0x87, 0x81, 0x8F, 0x94, 0x81, 0xDF, 0x37, 0x81,
  0x3F, 0xD4, 0x0E, 0x92, 0x0D, 0xB0, 0xD2, 0xA4, 0x81, 0xDF, 0x37, 0x81, 0x3F, 0xD4, 0x81, 0x9F,
  0x87, 0x81, 0x8F, 0xA4, 0x03, 0xA0, 0x35, 0x03, 0xA0, 0x35, 0x08, 0xA8, 0x38, 0x30, 0x38, 0xA0,
  0xA7, 0x08, 0xF8, 0x2A, 0xFD, 0x16, 0x89, 0x23, 0x9D, 0xFD, 0xA3, 0x0D, 0xFD, 0x17, 0x68, 0x31,
  0xDF, 0xD1, 0x76, 0x83, 0x1D, 0xFD, 0x17, 0x68, 0x21, 0xDF, 0xD7, 0x78, 0x11, 0xDC,
};

const RleImage4bppxBiased<Alpha4, ProgMemPtr>& ic_round_24_action_zoom_out() {
  static RleImage4bppxBiased<Alpha4, ProgMemPtr> value(
      Box(3, 3, 19, 19), Box(0, 0, 23, 23),
      ic_round_24_action_zoom_out_data, Alpha4(color::Black));
  return value;
}
