HugeIcons class

Free Hugeicons (stroke-rounded only) generated as full bundle.

Properties

hashCode → int

The hash code for this object.

no setter, inherited

runtimeType → Type

A representation of the runtime type of the object.

no setter, inherited

Methods

noSuchMethod(Invocation invocation) → dynamic

Invoked when a nonexistent method or property is accessed.

inherited

toString() → String

A string representation of this object.

inherited

Operators

operator ==(Object other) → bool

The equality operator.

inherited

Constants

strokeRounded0Circle → const List<List>

strokeRounded0Square → const List<List>

strokeRounded1Circle → const List<List>

strokeRounded1Square → const List<List>

strokeRounded1stBracket → const List<List>

strokeRounded1stBracketCircle → const List<List>

strokeRounded1stBracketSquare → const List<List>

strokeRounded1stBrecket → const List<List>

strokeRounded1stBrecketCircle → const List<List>

strokeRounded1stBrecketSquare → const List<List>

strokeRounded2Circle → const List<List>

strokeRounded2ndBracket → const List<List>

strokeRounded2ndBracketCircle → const List<List>

strokeRounded2ndBracketSquare → const List<List>

strokeRounded2ndBrecket → const List<List>

strokeRounded2ndBrecketCircle → const List<List>

strokeRounded2ndBrecketSquare → const List<List>

strokeRounded2Square → const List<List>

strokeRounded3Circle → const List<List>

strokeRounded3DMove → const List<List>

strokeRounded3dMove → const List<List>

strokeRounded3dPrinter → const List<List>

strokeRounded3DRotate → const List<List>

strokeRounded3dRotate → const List<List>

strokeRounded3DScale → const List<List>

strokeRounded3dScale → const List<List>

strokeRounded3DView → const List<List>

strokeRounded3rdBracket → const List<List>

strokeRounded3rdBracketCircle → const List<List>

strokeRounded3rdBracketSquare → const List<List>

strokeRounded3rdBrecket → const List<List>

strokeRounded3rdBrecketCircle → const List<List>

strokeRounded3rdBrecketSquare → const List<List>

strokeRounded3Square → const List<List>

strokeRounded4Circle → const List<List>

strokeRounded4K → const List<List>

strokeRounded4Square → const List<List>

strokeRounded5Circle → const List<List>

strokeRounded5Square → const List<List>

strokeRounded6Circle → const List<List>

strokeRounded6Square → const List<List>

strokeRounded7Circle → const List<List>

strokeRounded7Square → const List<List>

strokeRounded7z01 → const List<List>

strokeRounded7z02 → const List<List>

strokeRounded8Circle → const List<List>

strokeRounded8Square → const List<List>

strokeRounded9Circle → const List<List>

strokeRounded9Square → const List<List>

strokeRounded24HoursClock → const List<List>

strokeRoundedAArrowDown → const List<List>

strokeRoundedAArrowUp → const List<List>

strokeRoundedAbacus → const List<List>

strokeRoundedAbsolute → const List<List>

strokeRoundedAcceleration → const List<List>

strokeRoundedAccess → const List<List>

strokeRoundedAccident → const List<List>

strokeRoundedAccountRecovery → const List<List>

strokeRoundedAccountSetting01 → const List<List>

strokeRoundedAccountSetting02 → const List<List>

strokeRoundedAccountSetting03 → const List<List>

strokeRoundedActivity01 → const List<List>

strokeRoundedActivity02 → const List<List>

strokeRoundedActivity03 → const List<List>

strokeRoundedActivity04 → const List<List>

strokeRoundedActivity05 → const List<List>

strokeRoundedActivityCircle → const List<List>

strokeRoundedActivitySpark → const List<List>

strokeRoundedAcute → const List<List>

strokeRoundedAdd01 → const List<List>

strokeRoundedAdd02 → const List<List>

strokeRoundedAddCircle → const List<List>

strokeRoundedAddCircleHalfDot → const List<List>

strokeRoundedAddFemale → const List<List>

strokeRoundedAddInvoice → const List<List>

strokeRoundedAddMale → const List<List>

strokeRoundedAddMoneyCircle → const List<List>

strokeRoundedAddressBook → const List<List>

strokeRoundedAddSquare → const List<List>

strokeRoundedAddTeam → const List<List>

strokeRoundedAddTeam02 → const List<List>

strokeRoundedAddToList → const List<List>

strokeRoundedAdjustPosition → const List<List>

strokeRoundedAdobeAfterEffect → const List<List>

strokeRoundedAdobeIllustrator → const List<List>

strokeRoundedAdobeIndesign → const List<List>

strokeRoundedAdobePhotoshop → const List<List>

strokeRoundedAdobePremier → const List<List>

strokeRoundedAdobeXd → const List<List>

strokeRoundedAdventure → const List<List>

strokeRoundedAdvertisement → const List<List>

strokeRoundedAdvertisiment → const List<List>

strokeRoundedAdzan → const List<List>

strokeRoundedAffiliate → const List<List>

strokeRoundedAgreement01 → const List<List>

strokeRoundedAgreement02 → const List<List>

strokeRoundedAgreement03 → const List<List>

strokeRoundedAiAudio → const List<List>

strokeRoundedAiBeautify → const List<List>

strokeRoundedAiBook → const List<List>

strokeRoundedAiBrain01 → const List<List>

strokeRoundedAiBrain02 → const List<List>

strokeRoundedAiBrain03 → const List<List>

strokeRoundedAiBrain04 → const List<List>

strokeRoundedAiBrain05 → const List<List>

strokeRoundedAiBrowser → const List<List>

strokeRoundedAiChat01 → const List<List>

strokeRoundedAiChat02 → const List<List>

strokeRoundedAiChemistry01 → const List<List>

strokeRoundedAiChemistry02 → const List<List>

strokeRoundedAiChemistry03 → const List<List>

strokeRoundedAiChip → const List<List>

strokeRoundedAiCloud → const List<List>

strokeRoundedAiCloud01 → const List<List>

strokeRoundedAiCloud02 → const List<List>

strokeRoundedAiComputer → const List<List>

strokeRoundedAiContentGenerator01 → const List<List>

strokeRoundedAiContentGenerator02 → const List<List>

strokeRoundedAiDna → const List<List>

strokeRoundedAids → const List<List>

strokeRoundedAiEditing → const List<List>

strokeRoundedAiEraser → const List<List>

strokeRoundedAiFile → const List<List>

strokeRoundedAiFolder01 → const List<List>

strokeRoundedAiFolder02 → const List<List>

strokeRoundedAiGame → const List<List>

strokeRoundedAiGenerative → const List<List>

strokeRoundedAiIdea → const List<List>

strokeRoundedAiImage → const List<List>

strokeRoundedAiInnovation01 → const List<List>

strokeRoundedAiInnovation02 → const List<List>

strokeRoundedAiInnovation03 → const List<List>

strokeRoundedAiLaptop → const List<List>

strokeRoundedAiLearning → const List<List>

strokeRoundedAiLock → const List<List>

strokeRoundedAiMagic → const List<List>

strokeRoundedAiMail → const List<List>

strokeRoundedAiMail01 → const List<List>

strokeRoundedAiMail02 → const List<List>

strokeRoundedAiMic → const List<List>

strokeRoundedAiNetwork → const List<List>

strokeRoundedAiPhone01 → const List<List>

strokeRoundedAiPhone02 → const List<List>

strokeRoundedAiProgramming → const List<List>

strokeRoundedAirbnb → const List<List>

strokeRoundedAircraftGame → const List<List>

strokeRoundedAirdrop → const List<List>

strokeRoundedAirplane01 → const List<List>

strokeRoundedAirplane02 → const List<List>

strokeRoundedAirplaneLanding01 → const List<List>

strokeRoundedAirplaneLanding02 → const List<List>

strokeRoundedAirplaneMode → const List<List>

strokeRoundedAirplaneModeOff → const List<List>

strokeRoundedAirplaneSeat → const List<List>

strokeRoundedAirplaneSeat02 → const List<List>

strokeRoundedAirplaneTakeOff01 → const List<List>

strokeRoundedAirplaneTakeOff02 → const List<List>

strokeRoundedAirplayLine → const List<List>

strokeRoundedAirpod01 → const List<List>

strokeRoundedAirpod02 → const List<List>

strokeRoundedAirpod03 → const List<List>

strokeRoundedAirport → const List<List>

strokeRoundedAirport02 → const List<List>

strokeRoundedAirportTower → const List<List>

strokeRoundedAiScan → const List<List>

strokeRoundedAiScheduling → const List<List>

strokeRoundedAiSearch → const List<List>

strokeRoundedAiSearch02 → const List<List>

strokeRoundedAiSecurity01 → const List<List>

strokeRoundedAiSecurity02 → const List<List>

strokeRoundedAiSecurity03 → const List<List>

strokeRoundedAiSetting → const List<List>

strokeRoundedAiSheets → const List<List>

strokeRoundedAiSmartwatch → const List<List>

strokeRoundedAiUser → const List<List>

strokeRoundedAiVideo → const List<List>

strokeRoundedAiView → const List<List>

strokeRoundedAiVisionRecognition → const List<List>

strokeRoundedAiVoice → const List<List>

strokeRoundedAiVoiceGenerator → const List<List>

strokeRoundedAiWebBrowsing → const List<List>

strokeRoundedAlAqsaMosque → const List<List>

strokeRoundedAlarmClock → const List<List>

strokeRoundedAlarmClockOff → const List<List>

strokeRoundedAlarmSmoke → const List<List>

strokeRoundedAlbum → const List<List>

strokeRoundedAlbum01 → const List<List>

strokeRoundedAlbum02 → const List<List>

strokeRoundedAlbumNotFound01 → const List<List>

strokeRoundedAlbumNotFound02 → const List<List>

strokeRoundedAlert01 → const List<List>

strokeRoundedAlert02 → const List<List>

strokeRoundedAlertCircle → const List<List>

strokeRoundedAlertDiamond → const List<List>

strokeRoundedAlertSquare → const List<List>

strokeRoundedAlgorithm → const List<List>

strokeRoundedAlien01 → const List<List>

strokeRoundedAlien02 → const List<List>

strokeRoundedAlignBottom → const List<List>

strokeRoundedAlignBoxBottomCenter → const List<List>

strokeRoundedAlignBoxBottomLeft → const List<List>

strokeRoundedAlignBoxBottomRight → const List<List>

strokeRoundedAlignBoxMiddleCenter → const List<List>

strokeRoundedAlignBoxMiddleLeft → const List<List>

strokeRoundedAlignBoxMiddleRight → const List<List>

strokeRoundedAlignBoxTopCenter → const List<List>

strokeRoundedAlignBoxTopLeft → const List<List>

strokeRoundedAlignBoxTopRight → const List<List>

strokeRoundedAlignHorizontalCenter → const List<List>

strokeRoundedAlignHorizontalDistributeEnd → const List<List>

strokeRoundedAlignHorizontalDistributeStart → const List<List>

strokeRoundedAlignHorizontalJustifyEnd → const List<List>

strokeRoundedAlignHorizontalJustifyStart → const List<List>

strokeRoundedAlignHorizontalSpaceAround → const List<List>

strokeRoundedAlignHorizontalSpaceBetween → const List<List>

strokeRoundedAlignKeyObject → const List<List>

strokeRoundedAlignLeft → const List<List>

strokeRoundedAlignRight → const List<List>

strokeRoundedAlignSelection → const List<List>

strokeRoundedAlignTop → const List<List>

strokeRoundedAlignVerticalCenter → const List<List>

strokeRoundedAlignVerticalDistributeCenter → const List<List>

strokeRoundedAlignVerticalDistributeEnd → const List<List>

strokeRoundedAlignVerticalDistributeStart → const List<List>

strokeRoundedAlignVerticalJustifyStart → const List<List>

strokeRoundedAlignVerticalSpaceBetween → const List<List>

strokeRoundedAllah → const List<List>

strokeRoundedAllBookmark → const List<List>

strokeRoundedAlms → const List<List>

strokeRoundedAlpha → const List<List>

strokeRoundedAlphabetArabic → const List<List>

strokeRoundedAlphabetBangla → const List<List>

strokeRoundedAlphabetChinese → const List<List>

strokeRoundedAlphabetGreek → const List<List>

strokeRoundedAlphabetHebrew → const List<List>

strokeRoundedAlphabetHindi → const List<List>

strokeRoundedAlphabetJapanese → const List<List>

strokeRoundedAlphabetKorean → const List<List>

strokeRoundedAlphabetThai → const List<List>

strokeRoundedAlphaCircle → const List<List>

strokeRoundedAlphaSquare → const List<List>

strokeRoundedAmazon → const List<List>

strokeRoundedAmbulance → const List<List>

strokeRoundedAmericanFootball → const List<List>

strokeRoundedAmie → const List<List>

strokeRoundedAmmo → const List<List>

strokeRoundedAmphora → const List<List>

strokeRoundedAmpoule → const List<List>

strokeRoundedAnalysisTextLink → const List<List>

strokeRoundedAnalytics01 → const List<List>

strokeRoundedAnalytics02 → const List<List>

strokeRoundedAnalytics03 → const List<List>

strokeRoundedAnalyticsDown → const List<List>

strokeRoundedAnalyticsUp → const List<List>

strokeRoundedAnchor → const List<List>

strokeRoundedAnchorPoint → const List<List>

strokeRoundedAndroid → const List<List>

strokeRoundedAngel → const List<List>

strokeRoundedAngle → const List<List>

strokeRoundedAngle01 → const List<List>

strokeRoundedAngry → const List<List>

strokeRoundedAngryBird → const List<List>

strokeRoundedAnonymous → const List<List>

strokeRoundedAntenna → const List<List>

strokeRoundedAnvil → const List<List>

strokeRoundedApartment → const List<List>

strokeRoundedApi → const List<List>

strokeRoundedApiGateway → const List<List>

strokeRoundedApple → const List<List>

strokeRoundedApple01 → const List<List>

strokeRoundedAppleFinder → const List<List>

strokeRoundedAppleIntelligence → const List<List>

strokeRoundedAppleMusic → const List<List>

strokeRoundedAppleNews → const List<List>

strokeRoundedApplePie → const List<List>

strokeRoundedAppleReminder → const List<List>

strokeRoundedAppleStocks → const List<List>

strokeRoundedAppleVisionPro → const List<List>

strokeRoundedAppointment01 → const List<List>

strokeRoundedAppointment02 → const List<List>

strokeRoundedApproximatelyEqual → const List<List>

strokeRoundedApproximatelyEqualCircle → const List<List>

strokeRoundedApproximatelyEqualSquare → const List<List>

strokeRoundedAppStore → const List<List>

strokeRoundedApricot → const List<List>

strokeRoundedApron → const List<List>

strokeRoundedArcBrowser → const List<List>

strokeRoundedArcher → const List<List>

strokeRoundedArchive → const List<List>

strokeRoundedArchive01 → const List<List>

strokeRoundedArchive02 → const List<List>

strokeRoundedArchive03 → const List<List>

strokeRoundedArchive04 → const List<List>

strokeRoundedArchiveArrowDown → const List<List>

strokeRoundedArchiveArrowUp → const List<List>

strokeRoundedArchiveOff03 → const List<List>

strokeRoundedArchiveOff04 → const List<List>

strokeRoundedArchiveRestore → const List<List>

strokeRoundedArmoredBoot → const List<List>

strokeRoundedArrange → const List<List>

strokeRoundedArrangeByLettersAZ → const List<List>

strokeRoundedArrangeByLettersZA → const List<List>

strokeRoundedArrangeByNumbers19 → const List<List>

strokeRoundedArrangeByNumbers91 → const List<List>

strokeRoundedArrowAllDirection → const List<List>

strokeRoundedArrowBigDownDash → const List<List>

strokeRoundedArrowBigLeftDash → const List<List>

strokeRoundedArrowBigRightDash → const List<List>

strokeRoundedArrowBigUpDash → const List<List>

strokeRoundedArrowDataTransferDiagonal → const List<List>

strokeRoundedArrowDataTransferHorizontal → const List<List>

strokeRoundedArrowDataTransferVertical → const List<List>

strokeRoundedArrowDiagonal → const List<List>

strokeRoundedArrowDown01 → const List<List>

strokeRoundedArrowDown02 → const List<List>

strokeRoundedArrowDown03 → const List<List>

strokeRoundedArrowDown04 → const List<List>

strokeRoundedArrowDown05 → const List<List>

strokeRoundedArrowDown10 → const List<List>

strokeRoundedArrowDownAZ → const List<List>

strokeRoundedArrowDownBig → const List<List>

strokeRoundedArrowDownDouble → const List<List>

strokeRoundedArrowDownFromLine → const List<List>

strokeRoundedArrowDownLeft01 → const List<List>

strokeRoundedArrowDownLeft02 → const List<List>

strokeRoundedArrowDownRight01 → const List<List>

strokeRoundedArrowDownRight02 → const List<List>

strokeRoundedArrowDownToDot → const List<List>

strokeRoundedArrowExpand → const List<List>

strokeRoundedArrowExpand01 → const List<List>

strokeRoundedArrowExpand02 → const List<List>

strokeRoundedArrowExpandDiagonal01 → const List<List>

strokeRoundedArrowExpandDiagonal02 → const List<List>

strokeRoundedArrowHorizontal → const List<List>

strokeRoundedArrowLeft01 → const List<List>

strokeRoundedArrowLeft02 → const List<List>

strokeRoundedArrowLeft03 → const List<List>

strokeRoundedArrowLeft04 → const List<List>

strokeRoundedArrowLeft05 → const List<List>

strokeRoundedArrowLeftBig → const List<List>

strokeRoundedArrowLeftDouble → const List<List>

strokeRoundedArrowLeftFromLine → const List<List>

strokeRoundedArrowLeftRight → const List<List>

strokeRoundedArrowMoveDownLeft → const List<List>

strokeRoundedArrowMoveDownRight → const List<List>

strokeRoundedArrowMoveLeftDown → const List<List>

strokeRoundedArrowMoveRightDown → const List<List>

strokeRoundedArrowMoveUpLeft → const List<List>

strokeRoundedArrowMoveUpRight → const List<List>

strokeRoundedArrowReloadHorizontal → const List<List>

strokeRoundedArrowReloadVertical → const List<List>

strokeRoundedArrowRight01 → const List<List>

strokeRoundedArrowRight02 → const List<List>

strokeRoundedArrowRight03 → const List<List>

strokeRoundedArrowRight04 → const List<List>

strokeRoundedArrowRight05 → const List<List>

strokeRoundedArrowRightBig → const List<List>

strokeRoundedArrowRightDouble → const List<List>

strokeRoundedArrowRightFromLine → const List<List>

strokeRoundedArrowShrink → const List<List>

strokeRoundedArrowShrink01 → const List<List>

strokeRoundedArrowShrink02 → const List<List>

strokeRoundedArrowTurnBackward → const List<List>

strokeRoundedArrowTurnDown → const List<List>

strokeRoundedArrowTurnForward → const List<List>

strokeRoundedArrowTurnUp → const List<List>

strokeRoundedArrowUp01 → const List<List>

strokeRoundedArrowUp02 → const List<List>

strokeRoundedArrowUp03 → const List<List>

strokeRoundedArrowUp04 → const List<List>

strokeRoundedArrowUp05 → const List<List>

strokeRoundedArrowUp10 → const List<List>

strokeRoundedArrowUpBig → const List<List>

strokeRoundedArrowUpDouble → const List<List>

strokeRoundedArrowUpDown → const List<List>

strokeRoundedArrowUpFromDot → const List<List>

strokeRoundedArrowUpFromLine → const List<List>

strokeRoundedArrowUpLeft01 → const List<List>

strokeRoundedArrowUpLeft02 → const List<List>

strokeRoundedArrowUpNarrowWide → const List<List>

strokeRoundedArrowUpRight01 → const List<List>

strokeRoundedArrowUpRight02 → const List<List>

strokeRoundedArrowUpRight03 → const List<List>

strokeRoundedArrowUpRightStack → const List<List>

strokeRoundedArrowUpWideNarrow → const List<List>

strokeRoundedArrowUpZA → const List<List>

strokeRoundedArrowVertical → const List<List>

strokeRoundedArtboard → const List<List>

strokeRoundedArtboardTool → const List<List>

strokeRoundedArtificialIntelligence01 → const List<List>

strokeRoundedArtificialIntelligence02 → const List<List>

strokeRoundedArtificialIntelligence03 → const List<List>

strokeRoundedArtificialIntelligence04 → const List<List>

strokeRoundedArtificialIntelligence05 → const List<List>

strokeRoundedArtificialIntelligence06 → const List<List>

strokeRoundedArtificialIntelligence07 → const List<List>

strokeRoundedArtificialIntelligence08 → const List<List>

strokeRoundedAspectRatio → const List<List>

strokeRoundedAssignments → const List<List>

strokeRoundedAsterisk → const List<List>

strokeRoundedAsterisk02 → const List<List>

strokeRoundedAsteroid01 → const List<List>

strokeRoundedAsteroid02 → const List<List>

strokeRoundedAstronaut01 → const List<List>

strokeRoundedAstronaut02 → const List<List>

strokeRoundedAt → const List<List>

strokeRoundedAtm01 → const List<List>

strokeRoundedAtm02 → const List<List>

strokeRoundedAtom01 → const List<List>

strokeRoundedAtom02 → const List<List>

strokeRoundedAtomicPower → const List<List>

strokeRoundedAttachment → const List<List>

strokeRoundedAttachment01 → const List<List>

strokeRoundedAttachment02 → const List<List>

strokeRoundedAttachmentCircle → const List<List>

strokeRoundedAttachmentSquare → const List<List>

strokeRoundedAuction → const List<List>

strokeRoundedAudioBook01 → const List<List>

strokeRoundedAudioBook02 → const List<List>

strokeRoundedAudioBook03 → const List<List>

strokeRoundedAudioBook04 → const List<List>

strokeRoundedAudioWave01 → const List<List>

strokeRoundedAudioWave02 → const List<List>

strokeRoundedAudit01 → const List<List>

strokeRoundedAudit02 → const List<List>

strokeRoundedAugmentedRealityAr → const List<List>

strokeRoundedAuthorized → const List<List>

strokeRoundedAutoConversations → const List<List>

strokeRoundedAutomotiveBattery01 → const List<List>

strokeRoundedAutomotiveBattery02 → const List<List>

strokeRoundedAvalanche → const List<List>

strokeRoundedAvocado → const List<List>

strokeRoundedAward01 → const List<List>

strokeRoundedAward02 → const List<List>

strokeRoundedAward03 → const List<List>

strokeRoundedAward04 → const List<List>

strokeRoundedAward05 → const List<List>

strokeRoundedAwsLambda → const List<List>

strokeRoundedAxe → const List<List>

strokeRoundedAxis3d → const List<List>

strokeRoundedBaby01 → const List<List>

strokeRoundedBaby02 → const List<List>

strokeRoundedBabyBed01 → const List<List>

strokeRoundedBabyBed02 → const List<List>

strokeRoundedBabyBottle → const List<List>

strokeRoundedBabyBoyDress → const List<List>

strokeRoundedBabyGirlDress → const List<List>

strokeRoundedBackground → const List<List>

strokeRoundedBackMuscleBody → const List<List>

strokeRoundedBackpack01 → const List<List>

strokeRoundedBackpack02 → const List<List>

strokeRoundedBackpack03 → const List<List>

strokeRoundedBackward01 → const List<List>

strokeRoundedBackward02 → const List<List>

strokeRoundedBacteria → const List<List>

strokeRoundedBadge → const List<List>

strokeRoundedBadgeAlert → const List<List>

strokeRoundedBadgeCent → const List<List>

strokeRoundedBadgeDollarSign → const List<List>

strokeRoundedBadgeEuro → const List<List>

strokeRoundedBadgeIndianRupee → const List<List>

strokeRoundedBadgeInfo → const List<List>

strokeRoundedBadgeJapaneseYen → const List<List>

strokeRoundedBadgePercent → const List<List>

strokeRoundedBadgePoundSterling → const List<List>

strokeRoundedBadgeRussianRuble → const List<List>

strokeRoundedBadgeSwissFranc → const List<List>

strokeRoundedBadgeTurkishLira → const List<List>

strokeRoundedBadminton → const List<List>

strokeRoundedBadmintonShuttle → const List<List>

strokeRoundedBalanceScale → const List<List>

strokeRoundedBalloons → const List<List>

strokeRoundedBanana → const List<List>

strokeRoundedBandage → const List<List>

strokeRoundedBank → const List<List>

strokeRoundedBarChart → const List<List>

strokeRoundedBarChartHorizontal → const List<List>

strokeRoundedBarCode01 → const List<List>

strokeRoundedBarCode02 → const List<List>

strokeRoundedBarcodeScan → const List<List>

strokeRoundedBarns → const List<List>

strokeRoundedBarrel → const List<List>

strokeRoundedBaseball → const List<List>

strokeRoundedBaseballBat → const List<List>

strokeRoundedBaseballHelmet → const List<List>

strokeRoundedBash → const List<List>

strokeRoundedBasketball01 → const List<List>

strokeRoundedBasketball02 → const List<List>

strokeRoundedBasketballHoop → const List<List>

strokeRoundedBathtub01 → const List<List>

strokeRoundedBathtub02 → const List<List>

strokeRoundedBatteriesEnergy → const List<List>

strokeRoundedBatteryCharging01 → const List<List>

strokeRoundedBatteryCharging02 → const List<List>

strokeRoundedBatteryEcoCharging → const List<List>

strokeRoundedBatteryEmpty → const List<List>

strokeRoundedBatteryFull → const List<List>

strokeRoundedBatteryLow → const List<List>

strokeRoundedBatteryMedium01 → const List<List>

strokeRoundedBatteryMedium02 → const List<List>

strokeRoundedBatteryPlus → const List<List>

strokeRoundedBatteryWarning → const List<List>

strokeRoundedBbqGrill → const List<List>

strokeRoundedBeach → const List<List>

strokeRoundedBeach02 → const List<List>

strokeRoundedBean → const List<List>

strokeRoundedBeanOff → const List<List>

strokeRoundedBeater → const List<List>

strokeRoundedBebo → const List<List>

strokeRoundedBed → const List<List>

strokeRoundedBedBunk → const List<List>

strokeRoundedBedDouble → const List<List>

strokeRoundedBedSingle01 → const List<List>

strokeRoundedBedSingle02 → const List<List>

strokeRoundedBedug01 → const List<List>

strokeRoundedBedug02 → const List<List>

strokeRoundedBeef → const List<List>

strokeRoundedBehance01 → const List<List>

strokeRoundedBehance02 → const List<List>

strokeRoundedBellDot → const List<List>

strokeRoundedBellElectric → const List<List>

strokeRoundedBelt → const List<List>

strokeRoundedBendTool → const List<List>

strokeRoundedBerlin → const List<List>

strokeRoundedBerlinTower → const List<List>

strokeRoundedBeta → const List<List>

strokeRoundedBetweenHorizontalEnd → const List<List>

strokeRoundedBetweenVerticalEnd → const List<List>

strokeRoundedBicycle → const List<List>

strokeRoundedBicycle01 → const List<List>

strokeRoundedBilliard01 → const List<List>

strokeRoundedBilliard02 → const List<List>

strokeRoundedBinaryCode → const List<List>

strokeRoundedBing → const List<List>

strokeRoundedBinoculars → const List<List>

strokeRoundedBioEnergy → const List<List>

strokeRoundedBiohazard → const List<List>

strokeRoundedBiomassEnergy → const List<List>

strokeRoundedBiometricAccess → const List<List>

strokeRoundedBiometricDevice → const List<List>

strokeRoundedBird → const List<List>

strokeRoundedBirdhouse → const List<List>

strokeRoundedBirthdayCake → const List<List>

strokeRoundedBiscuit → const List<List>

strokeRoundedBitcoin → const List<List>

strokeRoundedBitcoin01 → const List<List>

strokeRoundedBitcoin02 → const List<List>

strokeRoundedBitcoin03 → const List<List>

strokeRoundedBitcoin04 → const List<List>

strokeRoundedBitcoinBag → const List<List>

strokeRoundedBitcoinCircle → const List<List>

strokeRoundedBitcoinCloud → const List<List>

strokeRoundedBitcoinCpu → const List<List>

strokeRoundedBitcoinCreditCard → const List<List>

strokeRoundedBitcoinDatabase → const List<List>

strokeRoundedBitcoinDown01 → const List<List>

strokeRoundedBitcoinDown02 → const List<List>

strokeRoundedBitcoinEllipse → const List<List>

strokeRoundedBitcoinEye → const List<List>

strokeRoundedBitcoinFilter → const List<List>

strokeRoundedBitcoinFlashdisk → const List<List>

strokeRoundedBitcoinGraph → const List<List>

strokeRoundedBitcoinInvoice → const List<List>

strokeRoundedBitcoinKey → const List<List>

strokeRoundedBitcoinLocation → const List<List>

strokeRoundedBitcoinLock → const List<List>

strokeRoundedBitcoinMail → const List<List>

strokeRoundedBitcoinMind → const List<List>

strokeRoundedBitcoinMoney01 → const List<List>

strokeRoundedBitcoinMoney02 → const List<List>

strokeRoundedBitcoinPieChart → const List<List>

strokeRoundedBitcoinPiggyBank → const List<List>

strokeRoundedBitcoinPresentation → const List<List>

strokeRoundedBitcoinReceipt → const List<List>

strokeRoundedBitcoinReceive → const List<List>

strokeRoundedBitcoinRectangle → const List<List>

strokeRoundedBitcoinSafe → const List<List>

strokeRoundedBitcoinSearch → const List<List>

strokeRoundedBitcoinSend → const List<List>

strokeRoundedBitcoinSetting → const List<List>

strokeRoundedBitcoinShield → const List<List>

strokeRoundedBitcoinShopping → const List<List>

strokeRoundedBitcoinSmartphone01 → const List<List>

strokeRoundedBitcoinSmartphone02 → const List<List>

strokeRoundedBitcoinSquare → const List<List>

strokeRoundedBitcoinStore → const List<List>

strokeRoundedBitcoinTag → const List<List>

strokeRoundedBitcoinTarget → const List<List>

strokeRoundedBitcoinTransaction → const List<List>

strokeRoundedBitcoinUp01 → const List<List>

strokeRoundedBitcoinUp02 → const List<List>

strokeRoundedBitcoinWallet → const List<List>

strokeRoundedBitcoinWithdraw → const List<List>

strokeRoundedBlackHole → const List<List>

strokeRoundedBlackHole01 → const List<List>

strokeRoundedBlend → const List<List>

strokeRoundedBlender → const List<List>

strokeRoundedBlinds → const List<List>

strokeRoundedBlockchain01 → const List<List>

strokeRoundedBlockchain02 → const List<List>

strokeRoundedBlockchain03 → const List<List>

strokeRoundedBlockchain04 → const List<List>

strokeRoundedBlockchain05 → const List<List>

strokeRoundedBlockchain06 → const List<List>

strokeRoundedBlockchain07 → const List<List>

strokeRoundedBlocked → const List<List>

strokeRoundedBlockGame → const List<List>

strokeRoundedBlogger → const List<List>

strokeRoundedBlood → const List<List>

strokeRoundedBloodBag → const List<List>

strokeRoundedBloodBottle → const List<List>

strokeRoundedBloodPressure → const List<List>

strokeRoundedBloodType → const List<List>

strokeRoundedBluesky → const List<List>

strokeRoundedBluetooth → const List<List>

strokeRoundedBluetoothCircle → const List<List>

strokeRoundedBluetoothNotConnected → const List<List>

strokeRoundedBluetoothSearch → const List<List>

strokeRoundedBluetoothSquare → const List<List>

strokeRoundedBlur → const List<List>

strokeRoundedBlushBrush01 → const List<List>

strokeRoundedBlushBrush02 → const List<List>

strokeRoundedBoardMath → const List<List>

strokeRoundedBoat → const List<List>

strokeRoundedBodyArmor → const List<List>

strokeRoundedBodyPartLeg → const List<List>

strokeRoundedBodyPartMuscle → const List<List>

strokeRoundedBodyPartSixPack → const List<List>

strokeRoundedBodySoap → const List<List>

strokeRoundedBodyWeight → const List<List>

strokeRoundedBomb → const List<List>

strokeRoundedBone01 → const List<List>

strokeRoundedBone02 → const List<List>

strokeRoundedBook01 → const List<List>

strokeRoundedBook02 → const List<List>

strokeRoundedBook03 → const List<List>

strokeRoundedBook04 → const List<List>

strokeRoundedBookA → const List<List>

strokeRoundedBookAlert → const List<List>

strokeRoundedBookBookmark01 → const List<List>

strokeRoundedBookBookmark02 → const List<List>

strokeRoundedBookCheck → const List<List>

strokeRoundedBookCopy → const List<List>

strokeRoundedBookDashed → const List<List>

strokeRoundedBookDownload → const List<List>

strokeRoundedBookEdit → const List<List>

strokeRoundedBookHeart → const List<List>

strokeRoundedBookImage → const List<List>

strokeRoundedBookKey → const List<List>

strokeRoundedBookLock → const List<List>

strokeRoundedBookmark01 → const List<List>

strokeRoundedBookmark02 → const List<List>

strokeRoundedBookmark03 → const List<List>

strokeRoundedBookmarkAdd01 → const List<List>

strokeRoundedBookmarkAdd02 → const List<List>

strokeRoundedBookmarkBlock01 → const List<List>

strokeRoundedBookmarkBlock02 → const List<List>

strokeRoundedBookmarkCheck01 → const List<List>

strokeRoundedBookmarkCheck02 → const List<List>

strokeRoundedBookmarkMinus01 → const List<List>

strokeRoundedBookmarkMinus02 → const List<List>

strokeRoundedBookmarkOff01 → const List<List>

strokeRoundedBookmarkOff02 → const List<List>

strokeRoundedBookmarkRemove01 → const List<List>

strokeRoundedBookmarkRemove02 → const List<List>

strokeRoundedBookMinus → const List<List>

strokeRoundedBookOpen01 → const List<List>

strokeRoundedBookOpen02 → const List<List>

strokeRoundedBookOpenCheck → const List<List>

strokeRoundedBookOpenText → const List<List>

strokeRoundedBookPlus → const List<List>

strokeRoundedBooks01 → const List<List>

strokeRoundedBooks02 → const List<List>

strokeRoundedBookSearch → const List<List>

strokeRoundedBookshelf01 → const List<List>

strokeRoundedBookshelf02 → const List<List>

strokeRoundedBookshelf03 → const List<List>

strokeRoundedBookType → const List<List>

strokeRoundedBookUp2 → const List<List>

strokeRoundedBookUpload → const List<List>

strokeRoundedBookUser → const List<List>

strokeRoundedBookX → const List<List>

strokeRoundedBoomBox → const List<List>

strokeRoundedBootstrap → const List<List>

strokeRoundedBorderAll01 → const List<List>

strokeRoundedBorderAll02 → const List<List>

strokeRoundedBorderBottom01 → const List<List>

strokeRoundedBorderBottom02 → const List<List>

strokeRoundedBorderFull → const List<List>

strokeRoundedBorderHorizontal → const List<List>

strokeRoundedBorderInner → const List<List>

strokeRoundedBorderLeft01 → const List<List>

strokeRoundedBorderLeft02 → const List<List>

strokeRoundedBorderNone01 → const List<List>

strokeRoundedBorderNone02 → const List<List>

strokeRoundedBorderRight01 → const List<List>

strokeRoundedBorderRight02 → const List<List>

strokeRoundedBorderTop01 → const List<List>

strokeRoundedBorderTop02 → const List<List>

strokeRoundedBorderVertical → const List<List>

strokeRoundedBorobudur → const List<List>

strokeRoundedBot → const List<List>

strokeRoundedBounceLeft → const List<List>

strokeRoundedBounceRight → const List<List>

strokeRoundedBoundingBox → const List<List>

strokeRoundedBowling → const List<List>

strokeRoundedBowlingBall → const List<List>

strokeRoundedBowlingPins → const List<List>

strokeRoundedBowTie → const List<List>

strokeRoundedBoxer → const List<List>

strokeRoundedBoxingBag → const List<List>

strokeRoundedBoxingGlove → const List<List>

strokeRoundedBoxingGlove01 → const List<List>

strokeRoundedBrain → const List<List>

strokeRoundedBrain01 → const List<List>

strokeRoundedBrain02 → const List<List>

strokeRoundedBrain03 → const List<List>

strokeRoundedBrainCog → const List<List>

strokeRoundedBrandfetch → const List<List>

strokeRoundedBread01 → const List<List>

strokeRoundedBread02 → const List<List>

strokeRoundedBread03 → const List<List>

strokeRoundedBread04 → const List<List>

strokeRoundedBreastPump → const List<List>

strokeRoundedBrickWall → const List<List>

strokeRoundedBrickWallShield → const List<List>

strokeRoundedBridge → const List<List>

strokeRoundedBriefcase01 → const List<List>

strokeRoundedBriefcase02 → const List<List>

strokeRoundedBriefcase03 → const List<List>

strokeRoundedBriefcase04 → const List<List>

strokeRoundedBriefcase05 → const List<List>

strokeRoundedBriefcase06 → const List<List>

strokeRoundedBriefcase07 → const List<List>

strokeRoundedBriefcase08 → const List<List>

strokeRoundedBriefcase09 → const List<List>

strokeRoundedBriefcaseConveyorBelt → const List<List>

strokeRoundedBriefcaseDollar → const List<List>

strokeRoundedBringToFront → const List<List>

strokeRoundedBroccoli → const List<List>

strokeRoundedBrochure → const List<List>

strokeRoundedBrokenBone → const List<List>

strokeRoundedBrowser → const List<List>

strokeRoundedBrush → const List<List>

strokeRoundedBubbleChat → const List<List>

strokeRoundedBubbleChatAdd → const List<List>

strokeRoundedBubbleChatBlocked → const List<List>

strokeRoundedBubbleChatCancel → const List<List>

strokeRoundedBubbleChatDelay → const List<List>

strokeRoundedBubbleChatDone → const List<List>

strokeRoundedBubbleChatDownload01 → const List<List>

strokeRoundedBubbleChatDownload02 → const List<List>

strokeRoundedBubbleChatEdit → const List<List>

strokeRoundedBubbleChatFavourite → const List<List>

strokeRoundedBubbleChatIncome → const List<List>

strokeRoundedBubbleChatLock → const List<List>

strokeRoundedBubbleChatNotification → const List<List>

strokeRoundedBubbleChatOutcome → const List<List>

strokeRoundedBubbleChatPreview → const List<List>

strokeRoundedBubbleChatQuestion → const List<List>

strokeRoundedBubbleChatSearch → const List<List>

strokeRoundedBubbleChatSecure → const List<List>

strokeRoundedBubbleChatSpark → const List<List>

strokeRoundedBubbleChatSpark01 → const List<List>

strokeRoundedBubbleChatTemporary → const List<List>

strokeRoundedBubbleChatTranslate → const List<List>

strokeRoundedBubbleChatUnlock → const List<List>

strokeRoundedBubbleChatUpload → const List<List>

strokeRoundedBubbleChatUser → const List<List>

strokeRoundedBubbles → const List<List>

strokeRoundedBubbleTea01 → const List<List>

strokeRoundedBubbleTea02 → const List<List>

strokeRoundedBucket → const List<List>

strokeRoundedBug01 → const List<List>

strokeRoundedBug02 → const List<List>

strokeRoundedBuilding01 → const List<List>

strokeRoundedBuilding02 → const List<List>

strokeRoundedBuilding03 → const List<List>

strokeRoundedBuilding04 → const List<List>

strokeRoundedBuilding05 → const List<List>

strokeRoundedBuilding06 → const List<List>

strokeRoundedBulb → const List<List>

strokeRoundedBulbCharging → const List<List>

strokeRoundedBullet → const List<List>

strokeRoundedBulletproofVest → const List<List>

strokeRoundedBurjAlArab → const List<List>

strokeRoundedBurningCd → const List<List>

strokeRoundedBus01 → const List<List>

strokeRoundedBus02 → const List<List>

strokeRoundedBus03 → const List<List>

strokeRoundedC → const List<List>

strokeRoundedCabinet01 → const List<List>

strokeRoundedCabinet02 → const List<List>

strokeRoundedCabinet03 → const List<List>

strokeRoundedCabinet04 → const List<List>

strokeRoundedCable → const List<List>

strokeRoundedCableCar → const List<List>

strokeRoundedCactus → const List<List>

strokeRoundedCaduceus → const List<List>

strokeRoundedCafe → const List<List>

strokeRoundedCakeSlice → const List<List>

strokeRoundedCalculate → const List<List>

strokeRoundedCalculator → const List<List>

strokeRoundedCalculator01 → const List<List>

strokeRoundedCalendar01 → const List<List>

strokeRoundedCalendar02 → const List<List>

strokeRoundedCalendar03 → const List<List>

strokeRoundedCalendar04 → const List<List>

strokeRoundedCalendar05 → const List<List>

strokeRoundedCalendarAdd01 → const List<List>

strokeRoundedCalendarAdd02 → const List<List>

strokeRoundedCalendarAnalysis → const List<List>

strokeRoundedCalendarBlock01 → const List<List>

strokeRoundedCalendarBlock02 → const List<List>

strokeRoundedCalendarCheckIn01 → const List<List>

strokeRoundedCalendarCheckIn02 → const List<List>

strokeRoundedCalendarCheckOut01 → const List<List>

strokeRoundedCalendarCheckOut02 → const List<List>

strokeRoundedCalendarDownload01 → const List<List>

strokeRoundedCalendarDownload02 → const List<List>

strokeRoundedCalendarFavorite01 → const List<List>

strokeRoundedCalendarFavorite02 → const List<List>

strokeRoundedCalendarFold → const List<List>

strokeRoundedCalendarLock01 → const List<List>

strokeRoundedCalendarLock02 → const List<List>

strokeRoundedCalendarLove01 → const List<List>

strokeRoundedCalendarLove02 → const List<List>

strokeRoundedCalendarMinus01 → const List<List>

strokeRoundedCalendarMinus02 → const List<List>

strokeRoundedCalendarMortarboard → const List<List>

strokeRoundedCalendarOff → const List<List>

strokeRoundedCalendarRemove01 → const List<List>

strokeRoundedCalendarRemove02 → const List<List>

strokeRoundedCalendars → const List<List>

strokeRoundedCalendarSetting01 → const List<List>

strokeRoundedCalendarSetting02 → const List<List>

strokeRoundedCalendarSync → const List<List>

strokeRoundedCalendarUpload01 → const List<List>

strokeRoundedCalendarUpload02 → const List<List>

strokeRoundedCalendarUser → const List<List>

strokeRoundedCall → const List<List>

strokeRoundedCall02 → const List<List>

strokeRoundedCallAdd → const List<List>

strokeRoundedCallAdd02 → const List<List>

strokeRoundedCallBlocked → const List<List>

strokeRoundedCallBlocked02 → const List<List>

strokeRoundedCallDisabled → const List<List>

strokeRoundedCallDisabled02 → const List<List>

strokeRoundedCallDone → const List<List>

strokeRoundedCallDone02 → const List<List>

strokeRoundedCallEnd01 → const List<List>

strokeRoundedCallEnd02 → const List<List>

strokeRoundedCallEnd03 → const List<List>

strokeRoundedCallEnd04 → const List<List>

strokeRoundedCallIncoming01 → const List<List>

strokeRoundedCallIncoming02 → const List<List>

strokeRoundedCallIncoming03 → const List<List>

strokeRoundedCallIncoming04 → const List<List>

strokeRoundedCalling → const List<List>

strokeRoundedCalling02 → const List<List>

strokeRoundedCallInternal → const List<List>

strokeRoundedCallInternal02 → const List<List>

strokeRoundedCallLocked → const List<List>

strokeRoundedCallLocked02 → const List<List>

strokeRoundedCallMinus → const List<List>

strokeRoundedCallMinus02 → const List<List>

strokeRoundedCallMissed01 → const List<List>

strokeRoundedCallMissed02 → const List<List>

strokeRoundedCallMissed03 → const List<List>

strokeRoundedCallMissed04 → const List<List>

strokeRoundedCallOutgoing01 → const List<List>

strokeRoundedCallOutgoing02 → const List<List>

strokeRoundedCallOutgoing03 → const List<List>

strokeRoundedCallOutgoing04 → const List<List>

strokeRoundedCallPaused → const List<List>

strokeRoundedCallPaused02 → const List<List>

strokeRoundedCallReceived → const List<List>

strokeRoundedCallReceived02 → const List<List>

strokeRoundedCallRinging01 → const List<List>

strokeRoundedCallRinging02 → const List<List>

strokeRoundedCallRinging03 → const List<List>

strokeRoundedCallRinging04 → const List<List>

strokeRoundedCallSpark01 → const List<List>

strokeRoundedCallSpark02 → const List<List>

strokeRoundedCallUnlocked → const List<List>

strokeRoundedCallUnlocked02 → const List<List>

strokeRoundedCamel → const List<List>

strokeRoundedCamera01 → const List<List>

strokeRoundedCamera02 → const List<List>

strokeRoundedCamera03 → const List<List>

strokeRoundedCameraAdd01 → const List<List>

strokeRoundedCameraAdd02 → const List<List>

strokeRoundedCameraAdd03 → const List<List>

strokeRoundedCameraAi → const List<List>

strokeRoundedCameraAutomatically01 → const List<List>

strokeRoundedCameraAutomatically02 → const List<List>

strokeRoundedCameraLens → const List<List>

strokeRoundedCameraMicrophone01 → const List<List>

strokeRoundedCameraMicrophone02 → const List<List>

strokeRoundedCameraNightMode01 → const List<List>

strokeRoundedCameraNightMode02 → const List<List>

strokeRoundedCameraOff01 → const List<List>

strokeRoundedCameraOff02 → const List<List>

strokeRoundedCameraRotated01 → const List<List>

strokeRoundedCameraRotated02 → const List<List>

strokeRoundedCameraSmile01 → const List<List>

strokeRoundedCameraSmile02 → const List<List>

strokeRoundedCameraTripod → const List<List>

strokeRoundedCameraVideo → const List<List>

strokeRoundedCamper → const List<List>

strokeRoundedCampfire → const List<List>

strokeRoundedCancel01 → const List<List>

strokeRoundedCancel02 → const List<List>

strokeRoundedCancelCircle → const List<List>

strokeRoundedCancelCircleHalfDot → const List<List>

strokeRoundedCancelSquare → const List<List>

strokeRoundedCandelier01 → const List<List>

strokeRoundedCandelier02 → const List<List>

strokeRoundedCandy → const List<List>

strokeRoundedCandyCane → const List<List>

strokeRoundedCandyOff → const List<List>

strokeRoundedCannabis → const List<List>

strokeRoundedCannabisOff → const List<List>

strokeRoundedCanvas → const List<List>

strokeRoundedCap → const List<List>

strokeRoundedCapcut → const List<List>

strokeRoundedCapcutRectangle → const List<List>

strokeRoundedCapProjecting → const List<List>

strokeRoundedCapRound → const List<List>

strokeRoundedCapStraight → const List<List>

strokeRoundedCar01 → const List<List>

strokeRoundedCar02 → const List<List>

strokeRoundedCar03 → const List<List>

strokeRoundedCar04 → const List<List>

strokeRoundedCar05 → const List<List>

strokeRoundedCarAlert → const List<List>

strokeRoundedCaravan → const List<List>

strokeRoundedCardExchange01 → const List<List>

strokeRoundedCardExchange02 → const List<List>

strokeRoundedCardigan → const List<List>

strokeRoundedCardiogram01 → const List<List>

strokeRoundedCardiogram02 → const List<List>

strokeRoundedCards01 → const List<List>

strokeRoundedCards02 → const List<List>

strokeRoundedCargoShip → const List<List>

strokeRoundedCarouselHorizontal → const List<List>

strokeRoundedCarouselHorizontal02 → const List<List>

strokeRoundedCarouselVertical → const List<List>

strokeRoundedCarParking01 → const List<List>

strokeRoundedCarParking02 → const List<List>

strokeRoundedCarrot → const List<List>

strokeRoundedCarSignal → const List<List>

strokeRoundedCarTime → const List<List>

strokeRoundedCash01 → const List<List>

strokeRoundedCash02 → const List<List>

strokeRoundedCashback → const List<List>

strokeRoundedCashbackBitcoin → const List<List>

strokeRoundedCashbackEuro → const List<List>

strokeRoundedCashbackPound → const List<List>

strokeRoundedCashbackYen → const List<List>

strokeRoundedCashier → const List<List>

strokeRoundedCashier02 → const List<List>

strokeRoundedCassetteTape → const List<List>

strokeRoundedCastbox → const List<List>

strokeRoundedCastle → const List<List>

strokeRoundedCastle01 → const List<List>

strokeRoundedCastle02 → const List<List>

strokeRoundedCatalogue → const List<List>

strokeRoundedCayanTower → const List<List>

strokeRoundedCctvCamera → const List<List>

strokeRoundedCd → const List<List>

strokeRoundedCells → const List<List>

strokeRoundedCellularNetwork → const List<List>

strokeRoundedCellularNetworkOffline → const List<List>

strokeRoundedCelsius → const List<List>

strokeRoundedCenterFocus → const List<List>

strokeRoundedCentralized → const List<List>

strokeRoundedCentralShaheedMinar → const List<List>

strokeRoundedCertificate01 → const List<List>

strokeRoundedCertificate02 → const List<List>

strokeRoundedChair01 → const List<List>

strokeRoundedChair02 → const List<List>

strokeRoundedChair03 → const List<List>

strokeRoundedChair04 → const List<List>

strokeRoundedChair05 → const List<List>

strokeRoundedChairBarber → const List<List>

strokeRoundedChampion → const List<List>

strokeRoundedChangeScreenMode → const List<List>

strokeRoundedCharacterPhonetic → const List<List>

strokeRoundedCharity → const List<List>

strokeRoundedChart → const List<List>

strokeRoundedChart01 → const List<List>

strokeRoundedChart02 → const List<List>

strokeRoundedChart03 → const List<List>

strokeRoundedChartAnalysis → const List<List>

strokeRoundedChartArea → const List<List>

strokeRoundedChartAverage → const List<List>

strokeRoundedChartBarBig → const List<List>

strokeRoundedChartBarDecreasing → const List<List>

strokeRoundedChartBarIncreasing → const List<List>

strokeRoundedChartBarLine → const List<List>

strokeRoundedChartBarStacked → const List<List>

strokeRoundedChartBreakoutCircle → const List<List>

strokeRoundedChartBreakoutSquare → const List<List>

strokeRoundedChartBubble01 → const List<List>

strokeRoundedChartBubble02 → const List<List>

strokeRoundedChartCandle → const List<List>

strokeRoundedChartCandlestick → const List<List>

strokeRoundedChartColumn → const List<List>

strokeRoundedChartColumnBig → const List<List>

strokeRoundedChartColumnDecreasing → const List<List>

strokeRoundedChartColumnStacked → const List<List>

strokeRoundedChartDecrease → const List<List>

strokeRoundedChartDown → const List<List>

strokeRoundedChartEvaluation → const List<List>

strokeRoundedChartGantt → const List<List>

strokeRoundedChartHighLow → const List<List>

strokeRoundedChartHistogram → const List<List>

strokeRoundedChartIncrease → const List<List>

strokeRoundedChartLineData01 → const List<List>

strokeRoundedChartLineData02 → const List<List>

strokeRoundedChartLineData03 → const List<List>

strokeRoundedChartMaximum → const List<List>

strokeRoundedChartMedium → const List<List>

strokeRoundedChartMinimum → const List<List>

strokeRoundedChartNoAxesColumnIncreasing → const List<List>

strokeRoundedChartNoAxesCombined → const List<List>

strokeRoundedChartNoAxesGantt → const List<List>

strokeRoundedChartRadar → const List<List>

strokeRoundedChartRelationship → const List<List>

strokeRoundedChartRing → const List<List>

strokeRoundedChartRose → const List<List>

strokeRoundedChartScatter → const List<List>

strokeRoundedChartUp → const List<List>

strokeRoundedChat → const List<List>

strokeRoundedChat01 → const List<List>

strokeRoundedChatAdd → const List<List>

strokeRoundedChatAdd01 → const List<List>

strokeRoundedChatBlocked → const List<List>

strokeRoundedChatBlocked01 → const List<List>

strokeRoundedChatBot → const List<List>

strokeRoundedChatCancel → const List<List>

strokeRoundedChatCancel01 → const List<List>

strokeRoundedChatDelay → const List<List>

strokeRoundedChatDelay01 → const List<List>

strokeRoundedChatDone → const List<List>

strokeRoundedChatDone01 → const List<List>

strokeRoundedChatDownload → const List<List>

strokeRoundedChatDownload01 → const List<List>

strokeRoundedChatEdit → const List<List>

strokeRoundedChatEdit01 → const List<List>

strokeRoundedChatFavourite → const List<List>

strokeRoundedChatFavourite01 → const List<List>

strokeRoundedChatFeedback → const List<List>

strokeRoundedChatFeedback01 → const List<List>

strokeRoundedChatGpt → const List<List>

strokeRoundedChatIncome → const List<List>

strokeRoundedChatIncome01 → const List<List>

strokeRoundedChatLock → const List<List>

strokeRoundedChatLock01 → const List<List>

strokeRoundedChatNotification → const List<List>

strokeRoundedChatNotification01 → const List<List>

strokeRoundedChatOutcome → const List<List>

strokeRoundedChatOutcome01 → const List<List>

strokeRoundedChatPreview → const List<List>

strokeRoundedChatPreview01 → const List<List>

strokeRoundedChatQuestion → const List<List>

strokeRoundedChatQuestion01 → const List<List>

strokeRoundedChatSearch → const List<List>

strokeRoundedChatSearch01 → const List<List>

strokeRoundedChatSecure → const List<List>

strokeRoundedChatSecure01 → const List<List>

strokeRoundedChatSpark → const List<List>

strokeRoundedChatSpark01 → const List<List>

strokeRoundedChatting01 → const List<List>

strokeRoundedChatTranslate → const List<List>

strokeRoundedChatTranslate01 → const List<List>

strokeRoundedChatUnlock → const List<List>

strokeRoundedChatUnlock01 → const List<List>

strokeRoundedChatUpload → const List<List>

strokeRoundedChatUpload01 → const List<List>

strokeRoundedChatUser → const List<List>

strokeRoundedChatUser01 → const List<List>

strokeRoundedCheckList → const List<List>

strokeRoundedCheckmarkBadge01 → const List<List>

strokeRoundedCheckmarkBadge02 → const List<List>

strokeRoundedCheckmarkBadge03 → const List<List>

strokeRoundedCheckmarkBadge04 → const List<List>

strokeRoundedCheckmarkCircle01 → const List<List>

strokeRoundedCheckmarkCircle02 → const List<List>

strokeRoundedCheckmarkCircle03 → const List<List>

strokeRoundedCheckmarkCircle04 → const List<List>

strokeRoundedCheckmarkSquare01 → const List<List>

strokeRoundedCheckmarkSquare02 → const List<List>

strokeRoundedCheckmarkSquare03 → const List<List>

strokeRoundedCheckmarkSquare04 → const List<List>

strokeRoundedCheckUnread01 → const List<List>

strokeRoundedCheckUnread02 → const List<List>

strokeRoundedCheckUnread03 → const List<List>

strokeRoundedCheckUnread04 → const List<List>

strokeRoundedCheese → const List<List>

strokeRoundedCheeseCake01 → const List<List>

strokeRoundedCheeseCake02 → const List<List>

strokeRoundedChef → const List<List>

strokeRoundedChefHat → const List<List>

strokeRoundedChemistry01 → const List<List>

strokeRoundedChemistry02 → const List<List>

strokeRoundedChemistry03 → const List<List>

strokeRoundedCherry → const List<List>

strokeRoundedChess01 → const List<List>

strokeRoundedChess02 → const List<List>

strokeRoundedChessBishop → const List<List>

strokeRoundedChessKing → const List<List>

strokeRoundedChessPawn → const List<List>

strokeRoundedChevronDoubleClose → const List<List>

strokeRoundedChevronsDownUp → const List<List>

strokeRoundedChickenThighs → const List<List>

strokeRoundedChild → const List<List>

strokeRoundedChimney → const List<List>

strokeRoundedChinaTemple → const List<List>

strokeRoundedChip → const List<List>

strokeRoundedChip02 → const List<List>

strokeRoundedChocolate → const List<List>

strokeRoundedChopsticks → const List<List>

strokeRoundedChrome → const List<List>

strokeRoundedChrysler → const List<List>

strokeRoundedChurch → const List<List>

strokeRoundedCigarette → const List<List>

strokeRoundedCigaretteOff → const List<List>

strokeRoundedCinnamonRoll → const List<List>

strokeRoundedCircle → const List<List>

strokeRoundedCircleArrowDataTransferDiagonal → const List<List>

strokeRoundedCircleArrowDataTransferHorizontal → const List<List>

strokeRoundedCircleArrowDataTransferVertical → const List<List>

strokeRoundedCircleArrowDiagonal01 → const List<List>

strokeRoundedCircleArrowDiagonal02 → const List<List>

strokeRoundedCircleArrowDown01 → const List<List>

strokeRoundedCircleArrowDown02 → const List<List>

strokeRoundedCircleArrowDown03 → const List<List>

strokeRoundedCircleArrowDownDouble → const List<List>

strokeRoundedCircleArrowDownLeft → const List<List>

strokeRoundedCircleArrowDownRight → const List<List>

strokeRoundedCircleArrowExpand01 → const List<List>

strokeRoundedCircleArrowExpand02 → const List<List>

strokeRoundedCircleArrowHorizontal → const List<List>

strokeRoundedCircleArrowLeft01 → const List<List>

strokeRoundedCircleArrowLeft02 → const List<List>

strokeRoundedCircleArrowLeft03 → const List<List>

strokeRoundedCircleArrowLeftDouble → const List<List>

strokeRoundedCircleArrowLeftRight → const List<List>

strokeRoundedCircleArrowMoveDownLeft → const List<List>

strokeRoundedCircleArrowMoveDownRight → const List<List>

strokeRoundedCircleArrowMoveLeftDown → const List<List>

strokeRoundedCircleArrowMoveRightDown → const List<List>

strokeRoundedCircleArrowMoveUpLeft → const List<List>

strokeRoundedCircleArrowMoveUpRight → const List<List>

strokeRoundedCircleArrowOutUpRight → const List<List>

strokeRoundedCircleArrowReload01 → const List<List>

strokeRoundedCircleArrowReload02 → const List<List>

strokeRoundedCircleArrowRight01 → const List<List>

strokeRoundedCircleArrowRight02 → const List<List>

strokeRoundedCircleArrowRight03 → const List<List>

strokeRoundedCircleArrowRightDouble → const List<List>

strokeRoundedCircleArrowShrink01 → const List<List>

strokeRoundedCircleArrowShrink02 → const List<List>

strokeRoundedCircleArrowUp01 → const List<List>

strokeRoundedCircleArrowUp02 → const List<List>

strokeRoundedCircleArrowUp03 → const List<List>

strokeRoundedCircleArrowUpDouble → const List<List>

strokeRoundedCircleArrowUpDown → const List<List>

strokeRoundedCircleArrowUpLeft → const List<List>

strokeRoundedCircleArrowUpRight → const List<List>

strokeRoundedCircleArrowUpRight02 → const List<List>

strokeRoundedCircleArrowVertical → const List<List>

strokeRoundedCircleLock01 → const List<List>

strokeRoundedCircleLock02 → const List<List>

strokeRoundedCircleLockAdd01 → const List<List>

strokeRoundedCircleLockAdd02 → const List<List>

strokeRoundedCircleLockCheck01 → const List<List>

strokeRoundedCircleLockCheck02 → const List<List>

strokeRoundedCircleLockMinus01 → const List<List>

strokeRoundedCircleLockMinus02 → const List<List>

strokeRoundedCircleLockRemove01 → const List<List>

strokeRoundedCircleLockRemove02 → const List<List>

strokeRoundedCircleParkingOff → const List<List>

strokeRoundedCirclePassword → const List<List>

strokeRoundedCirclePile → const List<List>

strokeRoundedCircleSlash2 → const List<List>

strokeRoundedCircleSmall → const List<List>

strokeRoundedCircleUnlock01 → const List<List>

strokeRoundedCircleUnlock02 → const List<List>

strokeRoundedCircuitBoard → const List<List>

strokeRoundedCitrus → const List<List>

strokeRoundedCity01 → const List<List>

strokeRoundedCity02 → const List<List>

strokeRoundedCity03 → const List<List>

strokeRoundedClapping01 → const List<List>

strokeRoundedClapping02 → const List<List>

strokeRoundedClaude → const List<List>

strokeRoundedClean → const List<List>

strokeRoundedCleaningBucket → const List<List>

strokeRoundedClinic → const List<List>

strokeRoundedClip → const List<List>

strokeRoundedCliparts → const List<List>

strokeRoundedClipboard → const List<List>

strokeRoundedClipboardClock → const List<List>

strokeRoundedClipboardCopy → const List<List>

strokeRoundedClipboardMinus → const List<List>

strokeRoundedClipboardPaste → const List<List>

strokeRoundedClock01 → const List<List>

strokeRoundedClock02 → const List<List>

strokeRoundedClock03 → const List<List>

strokeRoundedClock04 → const List<List>

strokeRoundedClock05 → const List<List>

strokeRoundedClockAdd → const List<List>

strokeRoundedClockAlert → const List<List>

strokeRoundedClockArrowDown → const List<List>

strokeRoundedClockArrowUp → const List<List>

strokeRoundedClockCheck → const List<List>

strokeRoundedClockPlus → const List<List>

strokeRoundedClosedCaption → const List<List>

strokeRoundedClosedCaptionAlt → const List<List>

strokeRoundedClothes → const List<List>

strokeRoundedCloud → const List<List>

strokeRoundedCloudAlert → const List<List>

strokeRoundedCloudAngledRain → const List<List>

strokeRoundedCloudAngledRainZap → const List<List>

strokeRoundedCloudAngledZap → const List<List>

strokeRoundedCloudBigRain → const List<List>

strokeRoundedCloudDownload → const List<List>

strokeRoundedCloudFastWind → const List<List>

strokeRoundedCloudHailstone → const List<List>

strokeRoundedCloudLittleRain → const List<List>

strokeRoundedCloudLittleSnow → const List<List>

strokeRoundedCloudLoading → const List<List>

strokeRoundedCloudMidRain → const List<List>

strokeRoundedCloudMidSnow → const List<List>

strokeRoundedCloudOff → const List<List>

strokeRoundedCloudSavingDone01 → const List<List>

strokeRoundedCloudSavingDone02 → const List<List>

strokeRoundedCloudServer → const List<List>

strokeRoundedCloudSlowWind → const List<List>

strokeRoundedCloudSnow → const List<List>

strokeRoundedCloudUpload → const List<List>

strokeRoundedClubs01 → const List<List>

strokeRoundedClubs02 → const List<List>

strokeRoundedCode → const List<List>

strokeRoundedCodeCircle → const List<List>

strokeRoundedCodeFolder → const List<List>

strokeRoundedCodepen → const List<List>

strokeRoundedCodesandbox → const List<List>

strokeRoundedCodeSimple → const List<List>

strokeRoundedCodeSquare → const List<List>

strokeRoundedCoffee01 → const List<List>

strokeRoundedCoffee02 → const List<List>

strokeRoundedCoffee03 → const List<List>

strokeRoundedCoffee04 → const List<List>

strokeRoundedCoffeeBeans → const List<List>

strokeRoundedCog → const List<List>

strokeRoundedCoinbase → const List<List>

strokeRoundedCoins01 → const List<List>

strokeRoundedCoins02 → const List<List>

strokeRoundedCoinsBitcoin → const List<List>

strokeRoundedCoinsDollar → const List<List>

strokeRoundedCoinsEuro → const List<List>

strokeRoundedCoinsPound → const List<List>

strokeRoundedCoinsSwap → const List<List>

strokeRoundedCoinsYen → const List<List>

strokeRoundedCollapse → const List<List>

strokeRoundedCollectionsBookmark → const List<List>

strokeRoundedColorPicker → const List<List>

strokeRoundedColors → const List<List>

strokeRoundedColosseum → const List<List>

strokeRoundedColumnDelete → const List<List>

strokeRoundedColumnInsert → const List<List>

strokeRoundedColumns3Cog → const List<List>

strokeRoundedCombine → const List<List>

strokeRoundedComet01 → const List<List>

strokeRoundedComet02 → const List<List>

strokeRoundedComingSoon01 → const List<List>

strokeRoundedComingSoon02 → const List<List>

strokeRoundedCommand → const List<List>

strokeRoundedCommandLine → const List<List>

strokeRoundedComment01 → const List<List>

strokeRoundedComment02 → const List<List>

strokeRoundedComment03 → const List<List>

strokeRoundedCommentAdd01 → const List<List>

strokeRoundedCommentAdd02 → const List<List>

strokeRoundedCommentAdd03 → const List<List>

strokeRoundedCommentBlock01 → const List<List>

strokeRoundedCommentBlock02 → const List<List>

strokeRoundedCommentBlock03 → const List<List>

strokeRoundedCommentRemove01 → const List<List>

strokeRoundedCommentRemove02 → const List<List>

strokeRoundedCommentRemove03 → const List<List>

strokeRoundedCompass → const List<List>

strokeRoundedCompass01 → const List<List>

strokeRoundedComplaint → const List<List>

strokeRoundedComponent → const List<List>

strokeRoundedComputer → const List<List>

strokeRoundedComputerActivity → const List<List>

strokeRoundedComputerAdd → const List<List>

strokeRoundedComputerArrowDown → const List<List>

strokeRoundedComputerArrowUp → const List<List>

strokeRoundedComputerChartDown → const List<List>

strokeRoundedComputerChartUp → const List<List>

strokeRoundedComputerCheck → const List<List>

strokeRoundedComputerCloud → const List<List>

strokeRoundedComputerDesk01 → const List<List>

strokeRoundedComputerDesk02 → const List<List>

strokeRoundedComputerDesk03 → const List<List>

strokeRoundedComputerDollar → const List<List>

strokeRoundedComputerEthernet → const List<List>

strokeRoundedComputerPhoneSync → const List<List>

strokeRoundedComputerProgramming01 → const List<List>

strokeRoundedComputerProgramming02 → const List<List>

strokeRoundedComputerProtection → const List<List>

strokeRoundedComputerRemove → const List<List>

strokeRoundedComputerScreenShare → const List<List>

strokeRoundedComputerSettings → const List<List>

strokeRoundedComputerTerminal01 → const List<List>

strokeRoundedComputerTerminal02 → const List<List>

strokeRoundedComputerUser → const List<List>

strokeRoundedComputerVideo → const List<List>

strokeRoundedComputerVideoCall → const List<List>

strokeRoundedCone01 → const List<List>

strokeRoundedCone02 → const List<List>

strokeRoundedConference → const List<List>

strokeRoundedConfiguration01 → const List<List>

strokeRoundedConfiguration02 → const List<List>

strokeRoundedConfused → const List<List>

strokeRoundedCongruentTo → const List<List>

strokeRoundedCongruentToCircle → const List<List>

strokeRoundedCongruentToSquare → const List<List>

strokeRoundedConnect → const List<List>

strokeRoundedConsole → const List<List>

strokeRoundedConstellation → const List<List>

strokeRoundedConstruction → const List<List>

strokeRoundedContact → const List<List>

strokeRoundedContact01 → const List<List>

strokeRoundedContact02 → const List<List>

strokeRoundedContactBook → const List<List>

strokeRoundedContainer → const List<List>

strokeRoundedContainerTruck → const List<List>

strokeRoundedContainerTruck01 → const List<List>

strokeRoundedContainerTruck02 → const List<List>

strokeRoundedContentWriting → const List<List>

strokeRoundedContracts → const List<List>

strokeRoundedConversation → const List<List>

strokeRoundedCookBook → const List<List>

strokeRoundedCookie → const List<List>

strokeRoundedCoordinate01 → const List<List>

strokeRoundedCoordinate02 → const List<List>

strokeRoundedCopilot → const List<List>

strokeRoundedCoPresent → const List<List>

strokeRoundedCopy → const List<List>

strokeRoundedCopy01 → const List<List>

strokeRoundedCopy02 → const List<List>

strokeRoundedCopyCheck → const List<List>

strokeRoundedCopyleft → const List<List>

strokeRoundedCopyLink → const List<List>

strokeRoundedCopyMinus → const List<List>

strokeRoundedCopyPlus → const List<List>

strokeRoundedCopyright → const List<List>

strokeRoundedCopySlash → const List<List>

strokeRoundedCorn → const List<List>

strokeRoundedCorporate → const List<List>

strokeRoundedCos → const List<List>

strokeRoundedCosine01 → const List<List>

strokeRoundedCosine02 → const List<List>

strokeRoundedCottage → const List<List>

strokeRoundedCottonCandy → const List<List>

strokeRoundedCoupon01 → const List<List>

strokeRoundedCoupon02 → const List<List>

strokeRoundedCoupon03 → const List<List>

strokeRoundedCouponPercent → const List<List>

strokeRoundedCourse → const List<List>

strokeRoundedCourtHouse → const List<List>

strokeRoundedCourtLaw → const List<List>

strokeRoundedCovariate → const List<List>

strokeRoundedCovidInfo → const List<List>

strokeRoundedCowboyHat → const List<List>

strokeRoundedCpp → const List<List>

strokeRoundedCProgramming → const List<List>

strokeRoundedCpu → const List<List>

strokeRoundedCpuCharge → const List<List>

strokeRoundedCpuSettings → const List<List>

strokeRoundedCrab → const List<List>

strokeRoundedCrane → const List<List>

strokeRoundedCrazy → const List<List>

strokeRoundedCreativeCommons → const List<List>

strokeRoundedCreativeMarket → const List<List>

strokeRoundedCreditCard → const List<List>

strokeRoundedCreditCardAccept → const List<List>

strokeRoundedCreditCardAdd → const List<List>

strokeRoundedCreditCardChange → const List<List>

strokeRoundedCreditCardDefrost → const List<List>

strokeRoundedCreditCardFreeze → const List<List>

strokeRoundedCreditCardNotAccept → const List<List>

strokeRoundedCreditCardNotFound → const List<List>

strokeRoundedCreditCardPos → const List<List>

strokeRoundedCreditCardValidation → const List<List>

strokeRoundedCricketBat → const List<List>

strokeRoundedCricketHelmet → const List<List>

strokeRoundedCroissant → const List<List>

strokeRoundedCrop → const List<List>

strokeRoundedCrowdfunding → const List<List>

strokeRoundedCrown → const List<List>

strokeRoundedCrown02 → const List<List>

strokeRoundedCrown03 → const List<List>

strokeRoundedCrownMinus → const List<List>

strokeRoundedCrownPlus → const List<List>

strokeRoundedCrying → const List<List>

strokeRoundedCss3 → const List<List>

strokeRoundedCssFile01 → const List<List>

strokeRoundedCssFile02 → const List<List>

strokeRoundedCsv01 → const List<List>

strokeRoundedCsv02 → const List<List>

strokeRoundedCube → const List<List>

strokeRoundedCupcake01 → const List<List>

strokeRoundedCupcake02 → const List<List>

strokeRoundedCupcake03 → const List<List>

strokeRoundedCurling → const List<List>

strokeRoundedCurrency → const List<List>

strokeRoundedCursor01 → const List<List>

strokeRoundedCursor02 → const List<List>

strokeRoundedCursorAddSelection01 → const List<List>

strokeRoundedCursorAddSelection02 → const List<List>

strokeRoundedCursorCircleSelection01 → const List<List>

strokeRoundedCursorCircleSelection02 → const List<List>

strokeRoundedCursorDisabled01 → const List<List>

strokeRoundedCursorDisabled02 → const List<List>

strokeRoundedCursorEdit01 → const List<List>

strokeRoundedCursorEdit02 → const List<List>

strokeRoundedCursorHold01 → const List<List>

strokeRoundedCursorHold02 → const List<List>

strokeRoundedCursorInfo01 → const List<List>

strokeRoundedCursorInfo02 → const List<List>

strokeRoundedCursorInWindow → const List<List>

strokeRoundedCursorLoading01 → const List<List>

strokeRoundedCursorLoading02 → const List<List>

strokeRoundedCursorMagicSelection01 → const List<List>

strokeRoundedCursorMagicSelection02 → const List<List>

strokeRoundedCursorMagicSelection03 → const List<List>

strokeRoundedCursorMagicSelection04 → const List<List>

strokeRoundedCursorMove01 → const List<List>

strokeRoundedCursorMove02 → const List<List>

strokeRoundedCursorPointer01 → const List<List>

strokeRoundedCursorPointer02 → const List<List>

strokeRoundedCursorProgress01 → const List<List>

strokeRoundedCursorProgress02 → const List<List>

strokeRoundedCursorProgress03 → const List<List>

strokeRoundedCursorProgress04 → const List<List>

strokeRoundedCursorRectangleSelection01 → const List<List>

strokeRoundedCursorRectangleSelection02 → const List<List>

strokeRoundedCursorRemoveSelection01 → const List<List>

strokeRoundedCursorRemoveSelection02 → const List<List>

strokeRoundedCursorText → const List<List>

strokeRoundedCurtains → const List<List>

strokeRoundedCurvyLeftDirection → const List<List>

strokeRoundedCurvyLeftRightDirection → const List<List>

strokeRoundedCurvyRightDirection → const List<List>

strokeRoundedCurvyUpDownDirection → const List<List>

strokeRoundedCustomerService → const List<List>

strokeRoundedCustomerService01 → const List<List>

strokeRoundedCustomerService02 → const List<List>

strokeRoundedCustomerSupport → const List<List>

strokeRoundedCustomField → const List<List>

strokeRoundedCustomize → const List<List>

strokeRoundedCylinder01 → const List<List>

strokeRoundedCylinder02 → const List<List>

strokeRoundedCylinder03 → const List<List>

strokeRoundedCylinder04 → const List<List>

strokeRoundedDam → const List<List>

strokeRoundedDanger → const List<List>

strokeRoundedDarkMode → const List<List>

strokeRoundedDart → const List<List>

strokeRoundedDashboardBrowsing → const List<List>

strokeRoundedDashboardCircle → const List<List>

strokeRoundedDashboardCircleAdd → const List<List>

strokeRoundedDashboardCircleEdit → const List<List>

strokeRoundedDashboardCircleRemove → const List<List>

strokeRoundedDashboardCircleSettings → const List<List>

strokeRoundedDashboardSpeed01 → const List<List>

strokeRoundedDashboardSpeed02 → const List<List>

strokeRoundedDashboardSquare01 → const List<List>

strokeRoundedDashboardSquare02 → const List<List>

strokeRoundedDashboardSquare03 → const List<List>

strokeRoundedDashboardSquareAdd → const List<List>

strokeRoundedDashboardSquareEdit → const List<List>

strokeRoundedDashboardSquareRemove → const List<List>

strokeRoundedDashboardSquareSetting → const List<List>

strokeRoundedDashedLine01 → const List<List>

strokeRoundedDashedLine02 → const List<List>

strokeRoundedDashedLineCircle → const List<List>

strokeRoundedDatabase → const List<List>

strokeRoundedDatabase01 → const List<List>

strokeRoundedDatabase02 → const List<List>

strokeRoundedDatabaseAdd → const List<List>

strokeRoundedDatabaseExpand → const List<List>

strokeRoundedDatabaseExport → const List<List>

strokeRoundedDatabaseImport → const List<List>

strokeRoundedDatabaseLightning → const List<List>

strokeRoundedDatabaseLocked → const List<List>

strokeRoundedDatabaseRestore → const List<List>

strokeRoundedDatabaseSetting → const List<List>

strokeRoundedDatabaseSync → const List<List>

strokeRoundedDatabaseSync01 → const List<List>

strokeRoundedDataRecovery → const List<List>

strokeRoundedDates → const List<List>

strokeRoundedDateTime → const List<List>

strokeRoundedDatev → const List<List>

strokeRoundedDead → const List<List>

strokeRoundedDeepseek → const List<List>

strokeRoundedDelete01 → const List<List>

strokeRoundedDelete02 → const List<List>

strokeRoundedDelete03 → const List<List>

strokeRoundedDelete04 → const List<List>

strokeRoundedDeleteColumn → const List<List>

strokeRoundedDeletePutBack → const List<List>

strokeRoundedDeleteRow → const List<List>

strokeRoundedDeleteThrow → const List<List>

strokeRoundedDeliveredSent → const List<List>

strokeRoundedDeliveryBox01 → const List<List>

strokeRoundedDeliveryBox02 → const List<List>

strokeRoundedDeliveryDelay01 → const List<List>

strokeRoundedDeliveryDelay02 → const List<List>

strokeRoundedDeliveryReturn01 → const List<List>

strokeRoundedDeliveryReturn02 → const List<List>

strokeRoundedDeliverySecure01 → const List<List>

strokeRoundedDeliverySecure02 → const List<List>

strokeRoundedDeliverySent01 → const List<List>

strokeRoundedDeliverySent02 → const List<List>

strokeRoundedDeliveryTracking01 → const List<List>

strokeRoundedDeliveryTracking02 → const List<List>

strokeRoundedDeliveryTruck01 → const List<List>

strokeRoundedDeliveryTruck02 → const List<List>

strokeRoundedDeliveryView01 → const List<List>

strokeRoundedDeliveryView02 → const List<List>

strokeRoundedDentalBraces → const List<List>

strokeRoundedDentalBrokenTooth → const List<List>

strokeRoundedDentalCare → const List<List>

strokeRoundedDentalTooth → const List<List>

strokeRoundedDepartement → const List<List>

strokeRoundedDesert → const List<List>

strokeRoundedDesk → const List<List>

strokeRoundedDesk01 → const List<List>

strokeRoundedDesk02 → const List<List>

strokeRoundedDetergent → const List<List>

strokeRoundedDeveloper → const List<List>

strokeRoundedDeviantart → const List<List>

strokeRoundedDeviceAccess → const List<List>

strokeRoundedDiagonalScrollPoint01 → const List<List>

strokeRoundedDiagonalScrollPoint02 → const List<List>

strokeRoundedDialpadCircle01 → const List<List>

strokeRoundedDialpadCircle02 → const List<List>

strokeRoundedDialpadSquare01 → const List<List>

strokeRoundedDialpadSquare02 → const List<List>

strokeRoundedDiameter → const List<List>

strokeRoundedDiamond → const List<List>

strokeRoundedDiamond01 → const List<List>

strokeRoundedDiamond02 → const List<List>

strokeRoundedDiamondMinus → const List<List>

strokeRoundedDiamondPercent → const List<List>

strokeRoundedDiamondPlus → const List<List>

strokeRoundedDiaper → const List<List>

strokeRoundedDice → const List<List>

strokeRoundedDiceFaces01 → const List<List>

strokeRoundedDiceFaces02 → const List<List>

strokeRoundedDiceFaces03 → const List<List>

strokeRoundedDiceFaces04 → const List<List>

strokeRoundedDiceFaces05 → const List<List>

strokeRoundedDiceFaces06 → const List<List>

strokeRoundedDigestion → const List<List>

strokeRoundedDigg → const List<List>

strokeRoundedDigitalClock → const List<List>

strokeRoundedDimSum01 → const List<List>

strokeRoundedDimSum02 → const List<List>

strokeRoundedDiningTable → const List<List>

strokeRoundedDiploma → const List<List>

strokeRoundedDirectionLeft01 → const List<List>

strokeRoundedDirectionLeft02 → const List<List>

strokeRoundedDirectionRight01 → const List<List>

strokeRoundedDirectionRight02 → const List<List>

strokeRoundedDirections01 → const List<List>

strokeRoundedDirections02 → const List<List>

strokeRoundedDirham → const List<List>

strokeRoundedDisability01 → const List<List>

strokeRoundedDisability02 → const List<List>

strokeRoundedDisc → const List<List>

strokeRoundedDisc2 → const List<List>

strokeRoundedDisc3 → const List<List>

strokeRoundedDiscAlbum → const List<List>

strokeRoundedDiscord → const List<List>

strokeRoundedDiscount → const List<List>

strokeRoundedDiscount01 → const List<List>

strokeRoundedDiscountTag01 → const List<List>

strokeRoundedDiscountTag02 → const List<List>

strokeRoundedDiscoverCircle → const List<List>

strokeRoundedDiscoverSquare → const List<List>

strokeRoundedDish01 → const List<List>

strokeRoundedDish02 → const List<List>

strokeRoundedDishWasher → const List<List>

strokeRoundedDispleased → const List<List>

strokeRoundedDistributeHorizontalCenter → const List<List>

strokeRoundedDistributeHorizontalLeft → const List<List>

strokeRoundedDistributeHorizontalRight → const List<List>

strokeRoundedDistributeVerticalBottom → const List<List>

strokeRoundedDistributeVerticalCenter → const List<List>

strokeRoundedDistributeVerticalTop → const List<List>

strokeRoundedDistribution → const List<List>

strokeRoundedDivideSign → const List<List>

strokeRoundedDivideSignCircle → const List<List>

strokeRoundedDivideSignSquare → const List<List>

strokeRoundedDna → const List<List>

strokeRoundedDna01 → const List<List>

strokeRoundedDoc01 → const List<List>

strokeRoundedDoc02 → const List<List>

strokeRoundedDoctor01 → const List<List>

strokeRoundedDoctor02 → const List<List>

strokeRoundedDoctor03 → const List<List>

strokeRoundedDocumentAttachment → const List<List>

strokeRoundedDocumentCode → const List<List>

strokeRoundedDocumentValidation → const List<List>

strokeRoundedDollar01 → const List<List>

strokeRoundedDollar02 → const List<List>

strokeRoundedDollarCircle → const List<List>

strokeRoundedDollarReceive01 → const List<List>

strokeRoundedDollarReceive02 → const List<List>

strokeRoundedDollarSend01 → const List<List>

strokeRoundedDollarSend02 → const List<List>

strokeRoundedDollarSquare → const List<List>

strokeRoundedDome → const List<List>

strokeRoundedDomino → const List<List>

strokeRoundedDoNotTouch01 → const List<List>

strokeRoundedDoNotTouch02 → const List<List>

strokeRoundedDoor → const List<List>

strokeRoundedDoor01 → const List<List>

strokeRoundedDoor02 → const List<List>

strokeRoundedDoorLock → const List<List>

strokeRoundedDoorOpen → const List<List>

strokeRoundedDoughnut → const List<List>

strokeRoundedDownload01 → const List<List>

strokeRoundedDownload02 → const List<List>

strokeRoundedDownload03 → const List<List>

strokeRoundedDownload04 → const List<List>

strokeRoundedDownload05 → const List<List>

strokeRoundedDownload06 → const List<List>

strokeRoundedDownloadCircle01 → const List<List>

strokeRoundedDownloadCircle02 → const List<List>

strokeRoundedDownloadSquare01 → const List<List>

strokeRoundedDownloadSquare02 → const List<List>

strokeRoundedDrag01 → const List<List>

strokeRoundedDrag02 → const List<List>

strokeRoundedDrag03 → const List<List>

strokeRoundedDrag04 → const List<List>

strokeRoundedDragDrop → const List<List>

strokeRoundedDragDropHorizontal → const List<List>

strokeRoundedDragDropVertical → const List<List>

strokeRoundedDragLeft01 → const List<List>

strokeRoundedDragLeft02 → const List<List>

strokeRoundedDragLeft03 → const List<List>

strokeRoundedDragLeft04 → const List<List>

strokeRoundedDragRight01 → const List<List>

strokeRoundedDragRight02 → const List<List>

strokeRoundedDragRight03 → const List<List>

strokeRoundedDragRight04 → const List<List>

strokeRoundedDrawingCompass → const List<List>

strokeRoundedDrawingMode → const List<List>

strokeRoundedDress01 → const List<List>

strokeRoundedDress02 → const List<List>

strokeRoundedDress03 → const List<List>

strokeRoundedDress04 → const List<List>

strokeRoundedDress05 → const List<List>

strokeRoundedDress06 → const List<List>

strokeRoundedDress07 → const List<List>

strokeRoundedDressingTable01 → const List<List>

strokeRoundedDressingTable02 → const List<List>

strokeRoundedDressingTable03 → const List<List>

strokeRoundedDribbble → const List<List>

strokeRoundedDrill → const List<List>

strokeRoundedDrink → const List<List>

strokeRoundedDrive → const List<List>

strokeRoundedDrone → const List<List>

strokeRoundedDrooling → const List<List>

strokeRoundedDropbox → const List<List>

strokeRoundedDropdownFieldType → const List<List>

strokeRoundedDroplet → const List<List>

strokeRoundedDropletOff → const List<List>

strokeRoundedDropper → const List<List>

strokeRoundedDs3Tool → const List<List>

strokeRoundedDua → const List<List>

strokeRoundedDumbbell01 → const List<List>

strokeRoundedDumbbell02 → const List<List>

strokeRoundedDumbbell03 → const List<List>

strokeRoundedDuplex → const List<List>

strokeRoundedEar → const List<List>

strokeRoundedEarOff → const List<List>

strokeRoundedEarRings01 → const List<List>

strokeRoundedEarRings02 → const List<List>

strokeRoundedEarRings03 → const List<List>

strokeRoundedEarth → const List<List>

strokeRoundedEarthLock → const List<List>

strokeRoundedEaseCurveControlPoints → const List<List>

strokeRoundedEaseIn → const List<List>

strokeRoundedEaseInControlPoint → const List<List>

strokeRoundedEaseInOut → const List<List>

strokeRoundedEaseOut → const List<List>

strokeRoundedEaseOutControlPoint → const List<List>

strokeRoundedEcoEnergy → const List<List>

strokeRoundedEcoLab → const List<List>

strokeRoundedEcoLab01 → const List<List>

strokeRoundedEcoLab02 → const List<List>

strokeRoundedEcoPower → const List<List>

strokeRoundedEdgeStyle → const List<List>

strokeRoundedEdit01 → const List<List>

strokeRoundedEdit02 → const List<List>

strokeRoundedEdit03 → const List<List>

strokeRoundedEdit04 → const List<List>

strokeRoundedEditOff → const List<List>

strokeRoundedEditOff03 → const List<List>

strokeRoundedEditOff04 → const List<List>

strokeRoundedEditRoad → const List<List>

strokeRoundedEditTable → const List<List>

strokeRoundedEditUser02 → const List<List>

strokeRoundedEgg → const List<List>

strokeRoundedEggFried → const List<List>

strokeRoundedEggOff → const List<List>

strokeRoundedEggs → const List<List>

strokeRoundedEidMubarak → const List<List>

strokeRoundedEiffelTower → const List<List>

strokeRoundedEightCircle → const List<List>

strokeRoundedEightSquare → const List<List>

strokeRoundedElearningExchange → const List<List>

strokeRoundedElectricHome01 → const List<List>

strokeRoundedElectricHome02 → const List<List>

strokeRoundedElectricityStack → const List<List>

strokeRoundedElectricPlugs → const List<List>

strokeRoundedElectricTower01 → const List<List>

strokeRoundedElectricTower02 → const List<List>

strokeRoundedElectricWire → const List<List>

strokeRoundedEllipseSelection → const List<List>

strokeRoundedEncrypt → const List<List>

strokeRoundedEnergy → const List<List>

strokeRoundedEnergyEllipse → const List<List>

strokeRoundedEnergyRectangle → const List<List>

strokeRoundedEngine → const List<List>

strokeRoundedEngineSlash → const List<List>

strokeRoundedEnteringGeoFence → const List<List>

strokeRoundedEntranceStairs → const List<List>

strokeRoundedEnvato → const List<List>

strokeRoundedEqualSign → const List<List>

strokeRoundedEqualSignCircle → const List<List>

strokeRoundedEqualSignSquare → const List<List>

strokeRoundedEquipmentBenchPress → const List<List>

strokeRoundedEquipmentChestPress → const List<List>

strokeRoundedEquipmentGym01 → const List<List>

strokeRoundedEquipmentGym02 → const List<List>

strokeRoundedEquipmentGym03 → const List<List>

strokeRoundedEquipmentWeightlifting → const List<List>

strokeRoundedEraser → const List<List>

strokeRoundedEraser01 → const List<List>

strokeRoundedEraserAdd → const List<List>

strokeRoundedEraserAuto → const List<List>

strokeRoundedEstimate01 → const List<List>

strokeRoundedEstimate02 → const List<List>

strokeRoundedEthereum → const List<List>

strokeRoundedEthereumEllipse → const List<List>

strokeRoundedEthereumRectangle → const List<List>

strokeRoundedEthernetPort → const List<List>

strokeRoundedEuro → const List<List>

strokeRoundedEuroCircle → const List<List>

strokeRoundedEuroReceive → const List<List>

strokeRoundedEuroSend → const List<List>

strokeRoundedEuroSquare → const List<List>

strokeRoundedEvCharging → const List<List>

strokeRoundedEvil → const List<List>

strokeRoundedExchange01 → const List<List>

strokeRoundedExchange02 → const List<List>

strokeRoundedExchange03 → const List<List>

strokeRoundedExchangeBitcoin → const List<List>

strokeRoundedExchangeDollar → const List<List>

strokeRoundedExclamationMark → const List<List>

strokeRoundedExclamationMarkBig → const List<List>

strokeRoundedExclamationMarkBigSlash → const List<List>

strokeRoundedExclamationMarkSlash → const List<List>

strokeRoundedExpand → const List<List>

strokeRoundedExpander → const List<List>

strokeRoundedExpandParagraph → const List<List>

strokeRoundedExternalDrive → const List<List>

strokeRoundedEye → const List<List>

strokeRoundedFacebook01 → const List<List>

strokeRoundedFacebook02 → const List<List>

strokeRoundedFaceId → const List<List>

strokeRoundedFactory → const List<List>

strokeRoundedFactory01 → const List<List>

strokeRoundedFactory02 → const List<List>

strokeRoundedFahrenheit → const List<List>

strokeRoundedFallingStar → const List<List>

strokeRoundedFan01 → const List<List>

strokeRoundedFan02 → const List<List>

strokeRoundedFastWind → const List<List>

strokeRoundedFavourite → const List<List>

strokeRoundedFavouriteCircle → const List<List>

strokeRoundedFavouriteSquare → const List<List>

strokeRoundedFeather → const List<List>

strokeRoundedFemale02 → const List<List>

strokeRoundedFemaleSymbol → const List<List>

strokeRoundedFence → const List<List>

strokeRoundedFencing → const List<List>

strokeRoundedFencingMask → const List<List>

strokeRoundedFerrisWheel → const List<List>

strokeRoundedFerryBoat → const List<List>

strokeRoundedFigma → const List<List>

strokeRoundedFile01 → const List<List>

strokeRoundedFile02 → const List<List>

strokeRoundedFileAdd → const List<List>

strokeRoundedFileArchive → const List<List>

strokeRoundedFileAttachment → const List<List>

strokeRoundedFileAudio → const List<List>

strokeRoundedFileAxis3d → const List<List>

strokeRoundedFileBadge → const List<List>

strokeRoundedFileBitcoin → const List<List>

strokeRoundedFileBlock → const List<List>

strokeRoundedFileBookmark → const List<List>

strokeRoundedFileBox → const List<List>

strokeRoundedFileBraces → const List<List>

strokeRoundedFileChartColumn → const List<List>

strokeRoundedFileChartColumnIncreasing → const List<List>

strokeRoundedFileChartPie → const List<List>

strokeRoundedFileClock → const List<List>

strokeRoundedFileCloud → const List<List>

strokeRoundedFileCode → const List<List>

strokeRoundedFileCodeCorner → const List<List>

strokeRoundedFileCorrupt → const List<List>

strokeRoundedFileDatabase → const List<List>

strokeRoundedFileDiff → const List<List>

strokeRoundedFileDigit → const List<List>

strokeRoundedFileDollar → const List<List>

strokeRoundedFileDown → const List<List>

strokeRoundedFileDownload → const List<List>

strokeRoundedFileEdit → const List<List>

strokeRoundedFileEmpty01 → const List<List>

strokeRoundedFileEmpty02 → const List<List>

strokeRoundedFileEuro → const List<List>

strokeRoundedFileExclamationPoint → const List<List>

strokeRoundedFileExport → const List<List>

strokeRoundedFileFavourite → const List<List>

strokeRoundedFileHeadphone → const List<List>

strokeRoundedFileHeart → const List<List>

strokeRoundedFileImage → const List<List>

strokeRoundedFileImport → const List<List>

strokeRoundedFileInput → const List<List>

strokeRoundedFileKey → const List<List>

strokeRoundedFileLink → const List<List>

strokeRoundedFileLock → const List<List>

strokeRoundedFileLocked → const List<List>

strokeRoundedFileManagement → const List<List>

strokeRoundedFileMinus → const List<List>

strokeRoundedFileMusic → const List<List>

strokeRoundedFileNotFound → const List<List>

strokeRoundedFilePaste → const List<List>

strokeRoundedFilePen → const List<List>

strokeRoundedFilePin → const List<List>

strokeRoundedFilePlay → const List<List>

strokeRoundedFilePlus → const List<List>

strokeRoundedFilePound → const List<List>

strokeRoundedFileQuestionMark → const List<List>

strokeRoundedFileRemove → const List<List>

strokeRoundedFiles01 → const List<List>

strokeRoundedFiles02 → const List<List>

strokeRoundedFileScan → const List<List>

strokeRoundedFileScript → const List<List>

strokeRoundedFileSearch → const List<List>

strokeRoundedFileSecurity → const List<List>

strokeRoundedFileShredder → const List<List>

strokeRoundedFileSignal → const List<List>

strokeRoundedFileSliders → const List<List>

strokeRoundedFileSpreadsheet → const List<List>

strokeRoundedFileStack → const List<List>

strokeRoundedFileStar → const List<List>

strokeRoundedFileSync → const List<List>

strokeRoundedFileTerminal → const List<List>

strokeRoundedFileType → const List<List>

strokeRoundedFileUnknown → const List<List>

strokeRoundedFileUnlocked → const List<List>

strokeRoundedFileUp → const List<List>

strokeRoundedFileUpload → const List<List>

strokeRoundedFileUser → const List<List>

strokeRoundedFileValidation → const List<List>

strokeRoundedFileVerified → const List<List>

strokeRoundedFileVideo → const List<List>

strokeRoundedFileVideoCamera → const List<List>

strokeRoundedFileView → const List<List>

strokeRoundedFileVolume → const List<List>

strokeRoundedFileX → const List<List>

strokeRoundedFileXCorner → const List<List>

strokeRoundedFileYen → const List<List>

strokeRoundedFileZip → const List<List>

strokeRoundedFilm01 → const List<List>

strokeRoundedFilm02 → const List<List>

strokeRoundedFilmRoll01 → const List<List>

strokeRoundedFilmRoll02 → const List<List>

strokeRoundedFilter → const List<List>

strokeRoundedFilterAdd → const List<List>

strokeRoundedFilterEdit → const List<List>

strokeRoundedFilterHorizontal → const List<List>

strokeRoundedFilterMail → const List<List>

strokeRoundedFilterMailCircle → const List<List>

strokeRoundedFilterMailEdit → const List<List>

strokeRoundedFilterMailRemove → const List<List>

strokeRoundedFilterMailSquare → const List<List>

strokeRoundedFilterRemove → const List<List>

strokeRoundedFilterReset → const List<List>

strokeRoundedFilterVertical → const List<List>

strokeRoundedFingerAccess → const List<List>

strokeRoundedFingerPrint → const List<List>

strokeRoundedFingerPrintAdd → const List<List>

strokeRoundedFingerPrintCheck → const List<List>

strokeRoundedFingerPrintMinus → const List<List>

strokeRoundedFingerPrintRemove → const List<List>

strokeRoundedFingerPrintScan → const List<List>

strokeRoundedFingerprintScan → const List<List>

strokeRoundedFins → const List<List>

strokeRoundedFire → const List<List>

strokeRoundedFire02 → const List<List>

strokeRoundedFire03 → const List<List>

strokeRoundedFireExtinguisher → const List<List>

strokeRoundedFirePit → const List<List>

strokeRoundedFireSecurity → const List<List>

strokeRoundedFirewall → const List<List>

strokeRoundedFireworks → const List<List>

strokeRoundedFirstAidKit → const List<List>

strokeRoundedFishFood → const List<List>

strokeRoundedFishingHook → const List<List>

strokeRoundedFishOff → const List<List>

strokeRoundedFishSymbol → const List<List>

strokeRoundedFitToScreen → const List<List>

strokeRoundedFiveCircle → const List<List>

strokeRoundedFiverr → const List<List>

strokeRoundedFiveSquare → const List<List>

strokeRoundedFlag01 → const List<List>

strokeRoundedFlag02 → const List<List>

strokeRoundedFlag03 → const List<List>

strokeRoundedFlameKindling → const List<List>

strokeRoundedFlash → const List<List>

strokeRoundedFlashlight → const List<List>

strokeRoundedFlashOff → const List<List>

strokeRoundedFlaticon → const List<List>

strokeRoundedFlickr → const List<List>

strokeRoundedFlimSlate → const List<List>

strokeRoundedFlipBottom → const List<List>

strokeRoundedFlipHorizontal → const List<List>

strokeRoundedFlipLeft → const List<List>

strokeRoundedFlipPhone → const List<List>

strokeRoundedFlipRight → const List<List>

strokeRoundedFlipTop → const List<List>

strokeRoundedFlipVertical → const List<List>

strokeRoundedFloorPlan → const List<List>

strokeRoundedFloppyDisk → const List<List>

strokeRoundedFlow → const List<List>

strokeRoundedFlowchart01 → const List<List>

strokeRoundedFlowchart02 → const List<List>

strokeRoundedFlowCircle → const List<List>

strokeRoundedFlowConnection → const List<List>

strokeRoundedFlower → const List<List>

strokeRoundedFlowerPot → const List<List>

strokeRoundedFlowSquare → const List<List>

strokeRoundedFlushed → const List<List>

strokeRoundedFlyingHuman → const List<List>

strokeRoundedFocusPoint → const List<List>

strokeRoundedFolder01 → const List<List>

strokeRoundedFolder02 → const List<List>

strokeRoundedFolder03 → const List<List>

strokeRoundedFolderAdd → const List<List>

strokeRoundedFolderArchive → const List<List>

strokeRoundedFolderAttachment → const List<List>

strokeRoundedFolderAudio → const List<List>

strokeRoundedFolderBlock → const List<List>

strokeRoundedFolderCheck → const List<List>

strokeRoundedFolderClock → const List<List>

strokeRoundedFolderCloud → const List<List>

strokeRoundedFolderCode → const List<List>

strokeRoundedFolderCog → const List<List>

strokeRoundedFolderDetails → const List<List>

strokeRoundedFolderDetailsReference → const List<List>

strokeRoundedFolderDot → const List<List>

strokeRoundedFolderDownload → const List<List>

strokeRoundedFolderEdit → const List<List>

strokeRoundedFolderExport → const List<List>

strokeRoundedFolderFavourite → const List<List>

strokeRoundedFolderFileStorage → const List<List>

strokeRoundedFolderGit → const List<List>

strokeRoundedFolderGit2 → const List<List>

strokeRoundedFolderHeart → const List<List>

strokeRoundedFolderImport → const List<List>

strokeRoundedFolderInput → const List<List>

strokeRoundedFolderKanban → const List<List>

strokeRoundedFolderKey → const List<List>

strokeRoundedFolderLibrary → const List<List>

strokeRoundedFolderLinks → const List<List>

strokeRoundedFolderLocked → const List<List>

strokeRoundedFolderManagement → const List<List>

strokeRoundedFolderMinus → const List<List>

strokeRoundedFolderMoveIn → const List<List>

strokeRoundedFolderMoveTo → const List<List>

strokeRoundedFolderMusic → const List<List>

strokeRoundedFolderOff → const List<List>

strokeRoundedFolderOpen → const List<List>

strokeRoundedFolderOutput → const List<List>

strokeRoundedFolderPen → const List<List>

strokeRoundedFolderPin → const List<List>

strokeRoundedFolderRemove → const List<List>

strokeRoundedFolderRoot → const List<List>

strokeRoundedFolders → const List<List>

strokeRoundedFolderSearch → const List<List>

strokeRoundedFolderSearch2 → const List<List>

strokeRoundedFolderSecurity → const List<List>

strokeRoundedFolderShared01 → const List<List>

strokeRoundedFolderShared02 → const List<List>

strokeRoundedFolderShared03 → const List<List>

strokeRoundedFolderSymlink → const List<List>

strokeRoundedFolderSync → const List<List>

strokeRoundedFolderTransfer → const List<List>

strokeRoundedFolderTree → const List<List>

strokeRoundedFolderUnknown → const List<List>

strokeRoundedFolderUnlocked → const List<List>

strokeRoundedFolderUpload → const List<List>

strokeRoundedFolderVideo → const List<List>

strokeRoundedFolderView → const List<List>

strokeRoundedFolderZip → const List<List>

strokeRoundedFootball → const List<List>

strokeRoundedFootballPitch → const List<List>

strokeRoundedForgotPassword → const List<List>

strokeRoundedFork → const List<List>

strokeRoundedForrst → const List<List>

strokeRoundedFortress → const List<List>

strokeRoundedForward01 → const List<List>

strokeRoundedForward02 → const List<List>

strokeRoundedFourCircle → const List<List>

strokeRoundedFourFinger02 → const List<List>

strokeRoundedFourFinger03 → const List<List>

strokeRoundedFourK → const List<List>

strokeRoundedFourSquare → const List<List>

strokeRoundedFoursquare → const List<List>

strokeRoundedFramer → const List<List>

strokeRoundedFrameworks → const List<List>

strokeRoundedFrenchFries01 → const List<List>

strokeRoundedFrenchFries02 → const List<List>

strokeRoundedFridge → const List<List>

strokeRoundedFrisbee → const List<List>

strokeRoundedFry → const List<List>

strokeRoundedFuel → const List<List>

strokeRoundedFuel01 → const List<List>

strokeRoundedFuel02 → const List<List>

strokeRoundedFuelStation → const List<List>

strokeRoundedFullScreen → const List<List>

strokeRoundedFullscreen → const List<List>

strokeRoundedFullSignal → const List<List>

strokeRoundedFunction → const List<List>

strokeRoundedFunctionCircle → const List<List>

strokeRoundedFunctionOfX → const List<List>

strokeRoundedFunctionSquare → const List<List>

strokeRoundedGalaxy → const List<List>

strokeRoundedGalleryHorizontalEnd → const List<List>

strokeRoundedGame → const List<List>

strokeRoundedGameboy → const List<List>

strokeRoundedGameController01 → const List<List>

strokeRoundedGameController02 → const List<List>

strokeRoundedGameController03 → const List<List>

strokeRoundedGamepadDirectional → const List<List>

strokeRoundedGarage → const List<List>

strokeRoundedGarbageTruck → const List<List>

strokeRoundedGarlands → const List<List>

strokeRoundedGasPipe → const List<List>

strokeRoundedGasStove → const List<List>

strokeRoundedGears → const List<List>

strokeRoundedGem → const List<List>

strokeRoundedGeologyCrust → const List<List>

strokeRoundedGeometricShapes01 → const List<List>

strokeRoundedGeometricShapes02 → const List<List>

strokeRoundedGeorgianLari → const List<List>

strokeRoundedGibbousMoon → const List<List>

strokeRoundedGif01 → const List<List>

strokeRoundedGif02 → const List<List>

strokeRoundedGift → const List<List>

strokeRoundedGiftCard → const List<List>

strokeRoundedGiftCard02 → const List<List>

strokeRoundedGitbook → const List<List>

strokeRoundedGitBranch → const List<List>

strokeRoundedGitCommit → const List<List>

strokeRoundedGitCommitHorizontal → const List<List>

strokeRoundedGitCompare → const List<List>

strokeRoundedGitFork → const List<List>

strokeRoundedGithub → const List<List>

strokeRoundedGithub01 → const List<List>

strokeRoundedGitlab → const List<List>

strokeRoundedGitMerge → const List<List>

strokeRoundedGitPullRequest → const List<List>

strokeRoundedGitPullRequestClosed → const List<List>

strokeRoundedGitPullRequestDraft → const List<List>

strokeRoundedGiveBlood → const List<List>

strokeRoundedGivePill → const List<List>

strokeRoundedGlasses → const List<List>

strokeRoundedGlobal → const List<List>

strokeRoundedGlobalEditing → const List<List>

strokeRoundedGlobalEducation → const List<List>

strokeRoundedGlobalRefresh → const List<List>

strokeRoundedGlobalSearch → const List<List>

strokeRoundedGlobe → const List<List>

strokeRoundedGlobe02 → const List<List>

strokeRoundedGlobeX → const List<List>

strokeRoundedGlove → const List<List>

strokeRoundedGnome → const List<List>

strokeRoundedGoBackward5Sec → const List<List>

strokeRoundedGoBackward10Sec → const List<List>

strokeRoundedGoBackward15Sec → const List<List>

strokeRoundedGoBackward30Sec → const List<List>

strokeRoundedGoBackward60Sec → const List<List>

strokeRoundedGoForward5Sec → const List<List>

strokeRoundedGoForward10Sec → const List<List>

strokeRoundedGoForward15Sec → const List<List>

strokeRoundedGoForward30Sec → const List<List>

strokeRoundedGoForward60Sec → const List<List>

strokeRoundedGold → const List<List>

strokeRoundedGoldBuy → const List<List>

strokeRoundedGoldIngots → const List<List>

strokeRoundedGoldSell → const List<List>

strokeRoundedGolfBall → const List<List>

strokeRoundedGolfBat → const List<List>

strokeRoundedGolfCart → const List<List>

strokeRoundedGolfHole → const List<List>

strokeRoundedGoogle → const List<List>

strokeRoundedGoogleDoc → const List<List>

strokeRoundedGoogleDrive → const List<List>

strokeRoundedGoogleGemini → const List<List>

strokeRoundedGoogleHome → const List<List>

strokeRoundedGoogleLens → const List<List>

strokeRoundedGoogleMaps → const List<List>

strokeRoundedGooglePhotos → const List<List>

strokeRoundedGoogleSheet → const List<List>

strokeRoundedGps01 → const List<List>

strokeRoundedGps02 → const List<List>

strokeRoundedGpsDisconnected → const List<List>

strokeRoundedGpsOff01 → const List<List>

strokeRoundedGpsOff02 → const List<List>

strokeRoundedGpsSignal01 → const List<List>

strokeRoundedGpsSignal02 → const List<List>

strokeRoundedGpu → const List<List>

strokeRoundedGraduateFemale → const List<List>

strokeRoundedGraduateMale → const List<List>

strokeRoundedGraduationScroll → const List<List>

strokeRoundedGrapes → const List<List>

strokeRoundedGraphicCard → const List<List>

strokeRoundedGravity → const List<List>

strokeRoundedGreaterThan → const List<List>

strokeRoundedGreaterThanCircle → const List<List>

strokeRoundedGreaterThanSquare → const List<List>

strokeRoundedGreekHelmet → const List<List>

strokeRoundedGreenHouse → const List<List>

strokeRoundedGrid → const List<List>

strokeRoundedGrid02 → const List<List>

strokeRoundedGridOff → const List<List>

strokeRoundedGridTable → const List<List>

strokeRoundedGridView → const List<List>

strokeRoundedGrimacing → const List<List>

strokeRoundedGrinning → const List<List>

strokeRoundedGrok → const List<List>

strokeRoundedGrok02 → const List<List>

strokeRoundedGroup → const List<List>

strokeRoundedGroup01 → const List<List>

strokeRoundedGroupItems → const List<List>

strokeRoundedGroupLayers → const List<List>

strokeRoundedGuestHouse → const List<List>

strokeRoundedGun → const List<List>

strokeRoundedGymnastic → const List<List>

strokeRoundedGymnasticRings → const List<List>

strokeRoundedHackerrank → const List<List>

strokeRoundedHairClips → const List<List>

strokeRoundedHairDryer → const List<List>

strokeRoundedHaji → const List<List>

strokeRoundedHalal → const List<List>

strokeRoundedHalalLab → const List<List>

strokeRoundedHam → const List<List>

strokeRoundedHamburger01 → const List<List>

strokeRoundedHamburger02 → const List<List>

strokeRoundedHandBag01 → const List<List>

strokeRoundedHandBag02 → const List<List>

strokeRoundedHandBeater → const List<List>

strokeRoundedHandCoins → const List<List>

strokeRoundedHandcuffs → const List<List>

strokeRoundedHandGrab → const List<List>

strokeRoundedHandGrip → const List<List>

strokeRoundedHandHelping → const List<List>

strokeRoundedHandPointingDown01 → const List<List>

strokeRoundedHandPointingDown02 → const List<List>

strokeRoundedHandPointingDown03 → const List<List>

strokeRoundedHandPointingDown04 → const List<List>

strokeRoundedHandPointingLeft01 → const List<List>

strokeRoundedHandPointingLeft02 → const List<List>

strokeRoundedHandPointingLeft03 → const List<List>

strokeRoundedHandPointingLeft04 → const List<List>

strokeRoundedHandPointingRight01 → const List<List>

strokeRoundedHandPointingRight02 → const List<List>

strokeRoundedHandPointingRight03 → const List<List>

strokeRoundedHandPointingRight04 → const List<List>

strokeRoundedHandPrayer → const List<List>

strokeRoundedHandSanitizer → const List<List>

strokeRoundedHandsClapping → const List<List>

strokeRoundedHanger → const List<List>

strokeRoundedHangingClock → const List<List>

strokeRoundedHangout → const List<List>

strokeRoundedHappy → const List<List>

strokeRoundedHappy01 → const List<List>

strokeRoundedHardDrive → const List<List>

strokeRoundedHardDriveDownload → const List<List>

strokeRoundedHardDriveUpload → const List<List>

strokeRoundedHashtag → const List<List>

strokeRoundedHat → const List<List>

strokeRoundedHdd → const List<List>

strokeRoundedHdr01 → const List<List>

strokeRoundedHdr02 → const List<List>

strokeRoundedHeading → const List<List>

strokeRoundedHeading01 → const List<List>

strokeRoundedHeading02 → const List<List>

strokeRoundedHeading03 → const List<List>

strokeRoundedHeading04 → const List<List>

strokeRoundedHeading05 → const List<List>

strokeRoundedHeading06 → const List<List>

strokeRoundedHeadphoneMute → const List<List>

strokeRoundedHeadphones → const List<List>

strokeRoundedHeadset → const List<List>

strokeRoundedHeadsetConnected → const List<List>

strokeRoundedHeadsetOff → const List<List>

strokeRoundedHealtcare → const List<List>

strokeRoundedHealth → const List<List>

strokeRoundedHeartAdd → const List<List>

strokeRoundedHeartbreak → const List<List>

strokeRoundedHeartCheck → const List<List>

strokeRoundedHeartMinus → const List<List>

strokeRoundedHeartRemove → const List<List>

strokeRoundedHeater → const List<List>

strokeRoundedHelicopter → const List<List>

strokeRoundedHelpCircle → const List<List>

strokeRoundedHelpSquare → const List<List>

strokeRoundedHexagon → const List<List>

strokeRoundedHexagon01 → const List<List>

strokeRoundedHierarchy → const List<List>

strokeRoundedHierarchyCircle01 → const List<List>

strokeRoundedHierarchyCircle02 → const List<List>

strokeRoundedHierarchyCircle03 → const List<List>

strokeRoundedHierarchyFiles → const List<List>

strokeRoundedHierarchySquare01 → const List<List>

strokeRoundedHierarchySquare02 → const List<List>

strokeRoundedHierarchySquare03 → const List<List>

strokeRoundedHierarchySquare04 → const List<List>

strokeRoundedHierarchySquare05 → const List<List>

strokeRoundedHierarchySquare06 → const List<List>

strokeRoundedHierarchySquare07 → const List<List>

strokeRoundedHierarchySquare08 → const List<List>

strokeRoundedHierarchySquare10 → const List<List>

strokeRoundedHighHeels01 → const List<List>

strokeRoundedHighHeels02 → const List<List>

strokeRoundedHighlighter → const List<List>

strokeRoundedHijab → const List<List>

strokeRoundedHockey → const List<List>

strokeRoundedHold01 → const List<List>

strokeRoundedHold02 → const List<List>

strokeRoundedHold03 → const List<List>

strokeRoundedHold04 → const List<List>

strokeRoundedHold05 → const List<List>

strokeRoundedHoldLocked01 → const List<List>

strokeRoundedHoldLocked02 → const List<List>

strokeRoundedHoldPhone → const List<List>

strokeRoundedHologram → const List<List>

strokeRoundedHome01 → const List<List>

strokeRoundedHome02 → const List<List>

strokeRoundedHome03 → const List<List>

strokeRoundedHome04 → const List<List>

strokeRoundedHome05 → const List<List>

strokeRoundedHome06 → const List<List>

strokeRoundedHome07 → const List<List>

strokeRoundedHome08 → const List<List>

strokeRoundedHome09 → const List<List>

strokeRoundedHome10 → const List<List>

strokeRoundedHome11 → const List<List>

strokeRoundedHome12 → const List<List>

strokeRoundedHome13 → const List<List>

strokeRoundedHomeWifi → const List<List>

strokeRoundedHoney01 → const List<List>

strokeRoundedHoney02 → const List<List>

strokeRoundedHonor → const List<List>

strokeRoundedHonourStar → const List<List>

strokeRoundedHoodie → const List<List>

strokeRoundedHop → const List<List>

strokeRoundedHopOff → const List<List>

strokeRoundedHorizonalScrollPoint → const List<List>

strokeRoundedHorizontalResize → const List<List>

strokeRoundedHorse → const List<List>

strokeRoundedHorseHead → const List<List>

strokeRoundedHorseSaddle → const List<List>

strokeRoundedHospital01 → const List<List>

strokeRoundedHospital02 → const List<List>

strokeRoundedHospitalBed01 → const List<List>

strokeRoundedHospitalBed02 → const List<List>

strokeRoundedHospitalLocation → const List<List>

strokeRoundedHotAirBalloon → const List<List>

strokeRoundedHotdog → const List<List>

strokeRoundedHotel01 → const List<List>

strokeRoundedHotel02 → const List<List>

strokeRoundedHotelBell → const List<List>

strokeRoundedHotPrice → const List<List>

strokeRoundedHotspot → const List<List>

strokeRoundedHotspotOffline → const List<List>

strokeRoundedHotTube → const List<List>

strokeRoundedHourglass → const List<List>

strokeRoundedHourglassOff → const List<List>

strokeRoundedHouse01 → const List<List>

strokeRoundedHouse02 → const List<List>

strokeRoundedHouse03 → const List<List>

strokeRoundedHouse04 → const List<List>

strokeRoundedHouse05 → const List<List>

strokeRoundedHouseHeart → const List<List>

strokeRoundedHousePlus → const List<List>

strokeRoundedHouseSolarPanel → const List<List>

strokeRoundedHouseWifi → const List<List>

strokeRoundedHtml5 → const List<List>

strokeRoundedHtmlFile01 → const List<List>

strokeRoundedHtmlFile02 → const List<List>

strokeRoundedHugeicons → const List<List>

strokeRoundedHumidity → const List<List>

strokeRoundedHut → const List<List>

strokeRoundedHydroPower → const List<List>

strokeRoundedHyperbole → const List<List>

strokeRoundedIceCream01 → const List<List>

strokeRoundedIceCream02 → const List<List>

strokeRoundedIceCream03 → const List<List>

strokeRoundedIceCream04 → const List<List>

strokeRoundedIceCubes → const List<List>

strokeRoundedIceHockey → const List<List>

strokeRoundedIceSkating → const List<List>

strokeRoundedIco → const List<List>

strokeRoundedIconjar → const List<List>

strokeRoundedId → const List<List>

strokeRoundedIdCardLanyard → const List<List>

strokeRoundedIdea → const List<List>

strokeRoundedIdea01 → const List<List>

strokeRoundedIdentification → const List<List>

strokeRoundedIdentityCard → const List<List>

strokeRoundedIdNotVerified → const List<List>

strokeRoundedIdVerified → const List<List>

strokeRoundedImage01 → const List<List>

strokeRoundedImage02 → const List<List>

strokeRoundedImage03 → const List<List>

strokeRoundedImageActualSize → const List<List>

strokeRoundedImageAdd01 → const List<List>

strokeRoundedImageAdd02 → const List<List>

strokeRoundedImageComposition → const List<List>

strokeRoundedImageCompositionOval → const List<List>

strokeRoundedImageCounterClockwise → const List<List>

strokeRoundedImageCrop → const List<List>

strokeRoundedImageDelete01 → const List<List>

strokeRoundedImageDelete02 → const List<List>

strokeRoundedImageDone01 → const List<List>

strokeRoundedImageDone02 → const List<List>

strokeRoundedImageDownload → const List<List>

strokeRoundedImageDownload02 → const List<List>

strokeRoundedImageFlipHorizontal → const List<List>

strokeRoundedImageFlipVertical → const List<List>

strokeRoundedImageNotFound01 → const List<List>

strokeRoundedImageNotFound02 → const List<List>

strokeRoundedImagePlay → const List<List>

strokeRoundedImageRemove01 → const List<List>

strokeRoundedImageRemove02 → const List<List>

strokeRoundedImageRotationClockwise → const List<List>

strokeRoundedImageUpload → const List<List>

strokeRoundedImageUpload01 → const List<List>

strokeRoundedImo → const List<List>

strokeRoundedImportantBook → const List<List>

strokeRoundedInbox → const List<List>

strokeRoundedInboxCheck → const List<List>

strokeRoundedInboxDownload → const List<List>

strokeRoundedInboxUnread → const List<List>

strokeRoundedInboxUpload → const List<List>

strokeRoundedIncognito → const List<List>

strokeRoundedIndiaGate → const List<List>

strokeRoundedInequality01 → const List<List>

strokeRoundedInequality02 → const List<List>

strokeRoundedInequalityCircle01 → const List<List>

strokeRoundedInequalityCircle02 → const List<List>

strokeRoundedInequalitySquare01 → const List<List>

strokeRoundedInequalitySquare02 → const List<List>

strokeRoundedInfant → const List<List>

strokeRoundedInfinity01 → const List<List>

strokeRoundedInfinity02 → const List<List>

strokeRoundedInfinityCircle → const List<List>

strokeRoundedInfinitySquare → const List<List>

strokeRoundedInformationCircle → const List<List>

strokeRoundedInformationDiamond → const List<List>

strokeRoundedInformationSquare → const List<List>

strokeRoundedInjection → const List<List>

strokeRoundedInLove → const List<List>

strokeRoundedInputCursorText → const List<List>

strokeRoundedInputLongText → const List<List>

strokeRoundedInputNumeric → const List<List>

strokeRoundedInputShortText → const List<List>

strokeRoundedInputText → const List<List>

strokeRoundedInsertBottomImage → const List<List>

strokeRoundedInsertCenterImage → const List<List>

strokeRoundedInsertColumn → const List<List>

strokeRoundedInsertColumnLeft → const List<List>

strokeRoundedInsertColumnRight → const List<List>

strokeRoundedInsertPi → const List<List>

strokeRoundedInsertRow → const List<List>

strokeRoundedInsertRowDown → const List<List>

strokeRoundedInsertRowUp → const List<List>

strokeRoundedInsertTopImage → const List<List>

strokeRoundedInspectCode → const List<List>

strokeRoundedInstagram → const List<List>

strokeRoundedInstallingUpdates01 → const List<List>

strokeRoundedInstallingUpdates02 → const List<List>

strokeRoundedInternet → const List<List>

strokeRoundedInternetAntenna01 → const List<List>

strokeRoundedInternetAntenna02 → const List<List>

strokeRoundedInternetAntenna03 → const List<List>

strokeRoundedInternetAntenna04 → const List<List>

strokeRoundedInvestigation → const List<List>

strokeRoundedInvoice → const List<List>

strokeRoundedInvoice01 → const List<List>

strokeRoundedInvoice02 → const List<List>

strokeRoundedInvoice03 → const List<List>

strokeRoundedInvoice04 → const List<List>

strokeRoundedIpod → const List<List>

strokeRoundedIrisScan → const List<List>

strokeRoundedIsland → const List<List>

strokeRoundedIterationCcw → const List<List>

strokeRoundedIterationCw → const List<List>

strokeRoundedJar → const List<List>

strokeRoundedJava → const List<List>

strokeRoundedJavaScript → const List<List>

strokeRoundedJobLink → const List<List>

strokeRoundedJobSearch → const List<List>

strokeRoundedJobShare → const List<List>

strokeRoundedJoggerPants → const List<List>

strokeRoundedJoinBevel → const List<List>

strokeRoundedJoinRound → const List<List>

strokeRoundedJoinStraight → const List<List>

strokeRoundedJoker → const List<List>

strokeRoundedJoystick01 → const List<List>

strokeRoundedJoystick02 → const List<List>

strokeRoundedJoystick03 → const List<List>

strokeRoundedJoystick04 → const List<List>

strokeRoundedJoystick05 → const List<List>

strokeRoundedJpg01 → const List<List>

strokeRoundedJpg02 → const List<List>

strokeRoundedJsx01 → const List<List>

strokeRoundedJsx02 → const List<List>

strokeRoundedJsx03 → const List<List>

strokeRoundedJudge → const List<List>

strokeRoundedJumpers → const List<List>

strokeRoundedJupiter → const List<List>

strokeRoundedJusticeScale01 → const List<List>

strokeRoundedJusticeScale02 → const List<List>

strokeRoundedKaaba01 → const List<List>

strokeRoundedKaaba02 → const List<List>

strokeRoundedKanban → const List<List>

strokeRoundedKayak → const List<List>

strokeRoundedKeffiyeh → const List<List>

strokeRoundedKettle → const List<List>

strokeRoundedKettle01 → const List<List>

strokeRoundedKettlebell → const List<List>

strokeRoundedKetupat → const List<List>

strokeRoundedKey01 → const List<List>

strokeRoundedKey02 → const List<List>

strokeRoundedKeyboard → const List<List>

strokeRoundedKeyframe → const List<List>

strokeRoundedKeyframeAdd → const List<List>

strokeRoundedKeyframeAlignCenter → const List<List>

strokeRoundedKeyframeAlignHorizontal → const List<List>

strokeRoundedKeyframeAlignVertical → const List<List>

strokeRoundedKeyframeBottom → const List<List>

strokeRoundedKeyframeLeft → const List<List>

strokeRoundedKeyframeRemove → const List<List>

strokeRoundedKeyframeRight → const List<List>

strokeRoundedKeyframesDouble → const List<List>

strokeRoundedKeyframesDoubleAdd → const List<List>

strokeRoundedKeyframesDoubleRemove → const List<List>

strokeRoundedKeyframesMultiple → const List<List>

strokeRoundedKeyframesMultipleAdd → const List<List>

strokeRoundedKeyframesMultipleRemove → const List<List>

strokeRoundedKeyframeTop → const List<List>

strokeRoundedKeyGeneratorFob → const List<List>

strokeRoundedKickstarter01 → const List<List>

strokeRoundedKickstarter02 → const List<List>

strokeRoundedKid → const List<List>

strokeRoundedKidneys → const List<List>

strokeRoundedKimiAi → const List<List>

strokeRoundedKissing → const List<List>

strokeRoundedKitchenUtensils → const List<List>

strokeRoundedKite → const List<List>

strokeRoundedKlarna → const List<List>

strokeRoundedKnife01 → const List<List>

strokeRoundedKnife02 → const List<List>

strokeRoundedKnifeBread → const List<List>

strokeRoundedKnightShield → const List<List>

strokeRoundedKnives → const List<List>

strokeRoundedKnowledge01 → const List<List>

strokeRoundedKnowledge02 → const List<List>

strokeRoundedKoFi → const List<List>

strokeRoundedKurta → const List<List>

strokeRoundedKurta01 → const List<List>

strokeRoundedLabel → const List<List>

strokeRoundedLabelImportant → const List<List>

strokeRoundedLabor → const List<List>

strokeRoundedLabs → const List<List>

strokeRoundedLake → const List<List>

strokeRoundedLamp → const List<List>

strokeRoundedLamp01 → const List<List>

strokeRoundedLamp02 → const List<List>

strokeRoundedLamp03 → const List<List>

strokeRoundedLamp04 → const List<List>

strokeRoundedLamp05 → const List<List>

strokeRoundedLampWallDown → const List<List>

strokeRoundedLampWallUp → const List<List>

strokeRoundedLandmark → const List<List>

strokeRoundedLandPlot → const List<List>

strokeRoundedLanguageCircle → const List<List>

strokeRoundedLanguageSkill → const List<List>

strokeRoundedLanguageSquare → const List<List>

strokeRoundedLantern → const List<List>

strokeRoundedLaptop → const List<List>

strokeRoundedLaptopAdd → const List<List>

strokeRoundedLaptopCharging → const List<List>

strokeRoundedLaptopCheck → const List<List>

strokeRoundedLaptopCloud → const List<List>

strokeRoundedLaptopIssue → const List<List>

strokeRoundedLaptopPerformance → const List<List>

strokeRoundedLaptopPhoneSync → const List<List>

strokeRoundedLaptopProgramming → const List<List>

strokeRoundedLaptopRemove → const List<List>

strokeRoundedLaptopSettings → const List<List>

strokeRoundedLaptopVideo → const List<List>

strokeRoundedLassoSelect → const List<List>

strokeRoundedLassoTool01 → const List<List>

strokeRoundedLassoTool02 → const List<List>

strokeRoundedLastFm → const List<List>

strokeRoundedLatitude → const List<List>

strokeRoundedLaughing → const List<List>

strokeRoundedLaurelWreath01 → const List<List>

strokeRoundedLaurelWreath02 → const List<List>

strokeRoundedLaurelWreathFirst01 → const List<List>

strokeRoundedLaurelWreathFirst02 → const List<List>

strokeRoundedLaurelWreathLeft01 → const List<List>

strokeRoundedLaurelWreathLeft02 → const List<List>

strokeRoundedLaurelWreathLeft03 → const List<List>

strokeRoundedLaurelWreathRight01 → const List<List>

strokeRoundedLaurelWreathRight02 → const List<List>

strokeRoundedLaurelWreathRight03 → const List<List>

strokeRoundedLayer → const List<List>

strokeRoundedLayerAdd → const List<List>

strokeRoundedLayerBringForward → const List<List>

strokeRoundedLayerBringToFront → const List<List>

strokeRoundedLayerMask01 → const List<List>

strokeRoundedLayerMask02 → const List<List>

strokeRoundedLayers01 → const List<List>

strokeRoundedLayers02 → const List<List>

strokeRoundedLayerSendBackward → const List<List>

strokeRoundedLayerSendToBack → const List<List>

strokeRoundedLayersLogo → const List<List>

strokeRoundedLayout01 → const List<List>

strokeRoundedLayout2Column → const List<List>

strokeRoundedLayout2Row → const List<List>

strokeRoundedLayout02 → const List<List>

strokeRoundedLayout3Column → const List<List>

strokeRoundedLayout3Row → const List<List>

strokeRoundedLayout03 → const List<List>

strokeRoundedLayout04 → const List<List>

strokeRoundedLayout05 → const List<List>

strokeRoundedLayout06 → const List<List>

strokeRoundedLayout07 → const List<List>

strokeRoundedLayoutAlignBottom → const List<List>

strokeRoundedLayoutAlignLeft → const List<List>

strokeRoundedLayoutAlignRight → const List<List>

strokeRoundedLayoutAlignTop → const List<List>

strokeRoundedLayoutBottom → const List<List>

strokeRoundedLayoutGrid → const List<List>

strokeRoundedLayoutLeft → const List<List>

strokeRoundedLayoutRight → const List<List>

strokeRoundedLayoutTable01 → const List<List>

strokeRoundedLayoutTable02 → const List<List>

strokeRoundedLayoutTop → const List<List>

strokeRoundedLeaf01 → const List<List>

strokeRoundedLeaf02 → const List<List>

strokeRoundedLeaf03 → const List<List>

strokeRoundedLeaf04 → const List<List>

strokeRoundedLeafyGreen → const List<List>

strokeRoundedLeavingGeoFence → const List<List>

strokeRoundedLeetcode → const List<List>

strokeRoundedLeftAngle → const List<List>

strokeRoundedLeftToRightBlockQuote → const List<List>

strokeRoundedLeftToRightListBullet → const List<List>

strokeRoundedLeftToRightListDash → const List<List>

strokeRoundedLeftToRightListNumber → const List<List>

strokeRoundedLeftToRightListStar → const List<List>

strokeRoundedLeftToRightListStar01 → const List<List>

strokeRoundedLeftToRightListTriangle → const List<List>

strokeRoundedLeftTriangle → const List<List>

strokeRoundedLegal01 → const List<List>

strokeRoundedLegal02 → const List<List>

strokeRoundedLegalDocument01 → const List<List>

strokeRoundedLegalDocument02 → const List<List>

strokeRoundedLegalHammer → const List<List>

strokeRoundedLessThan → const List<List>

strokeRoundedLessThanCircle → const List<List>

strokeRoundedLessThanSquare → const List<List>

strokeRoundedLetterSpacing → const List<List>

strokeRoundedLibraries → const List<List>

strokeRoundedLibrary → const List<List>

strokeRoundedLicense → const List<List>

strokeRoundedLicenseDraft → const List<List>

strokeRoundedLicenseMaintenance → const List<List>

strokeRoundedLicenseNo → const List<List>

strokeRoundedLicensePin → const List<List>

strokeRoundedLicenseThirdParty → const List<List>

strokeRoundedLifebuoy → const List<List>

strokeRoundedLiftTruck → const List<List>

strokeRoundedLigature → const List<List>

strokeRoundedLightbulbOff → const List<List>

strokeRoundedLighthouse → const List<List>

strokeRoundedLimitation → const List<List>

strokeRoundedLimitOrder → const List<List>

strokeRoundedLine → const List<List>

strokeRoundedLiner → const List<List>

strokeRoundedLink01 → const List<List>

strokeRoundedLink02 → const List<List>

strokeRoundedLink03 → const List<List>

strokeRoundedLink04 → const List<List>

strokeRoundedLink05 → const List<List>

strokeRoundedLink06 → const List<List>

strokeRoundedLinkBackward → const List<List>

strokeRoundedLinkCircle → const List<List>

strokeRoundedLinkCircle02 → const List<List>

strokeRoundedLinkedin01 → const List<List>

strokeRoundedLinkedin02 → const List<List>

strokeRoundedLinkForward → const List<List>

strokeRoundedLinkSquare01 → const List<List>

strokeRoundedLinkSquare02 → const List<List>

strokeRoundedListChevronsDownUp → const List<List>

strokeRoundedListFilterPlus → const List<List>

strokeRoundedListIndentDecrease → const List<List>

strokeRoundedListIndentIncrease → const List<List>

strokeRoundedListMusic → const List<List>

strokeRoundedListPlus → const List<List>

strokeRoundedListRestart → const List<List>

strokeRoundedListSetting → const List<List>

strokeRoundedListStart → const List<List>

strokeRoundedListTree → const List<List>

strokeRoundedListVideo → const List<List>

strokeRoundedListView → const List<List>

strokeRoundedListX → const List<List>

strokeRoundedLitecoin → const List<List>

strokeRoundedLiver → const List<List>

strokeRoundedLiveStreaming01 → const List<List>

strokeRoundedLiveStreaming02 → const List<List>

strokeRoundedLiveStreaming03 → const List<List>

strokeRoundedLoaderPinwheel → const List<List>

strokeRoundedLoading01 → const List<List>

strokeRoundedLoading02 → const List<List>

strokeRoundedLoading03 → const List<List>

strokeRoundedLoading04 → const List<List>

strokeRoundedLocation01 → const List<List>

strokeRoundedLocation02 → const List<List>

strokeRoundedLocation03 → const List<List>

strokeRoundedLocation04 → const List<List>

strokeRoundedLocation05 → const List<List>

strokeRoundedLocation06 → const List<List>

strokeRoundedLocation07 → const List<List>

strokeRoundedLocation08 → const List<List>

strokeRoundedLocation09 → const List<List>

strokeRoundedLocation10 → const List<List>

strokeRoundedLocationAdd01 → const List<List>

strokeRoundedLocationAdd02 → const List<List>

strokeRoundedLocationCheck01 → const List<List>

strokeRoundedLocationCheck02 → const List<List>

strokeRoundedLocationFavourite01 → const List<List>

strokeRoundedLocationFavourite02 → const List<List>

strokeRoundedLocationOffline01 → const List<List>

strokeRoundedLocationOffline02 → const List<List>

strokeRoundedLocationOffline03 → const List<List>

strokeRoundedLocationOffline04 → const List<List>

strokeRoundedLocationRemove01 → const List<List>

strokeRoundedLocationRemove02 → const List<List>

strokeRoundedLocationShare01 → const List<List>

strokeRoundedLocationShare02 → const List<List>

strokeRoundedLocationStar01 → const List<List>

strokeRoundedLocationStar02 → const List<List>

strokeRoundedLocationUpdate01 → const List<List>

strokeRoundedLocationUpdate02 → const List<List>

strokeRoundedLocationUser01 → const List<List>

strokeRoundedLocationUser02 → const List<List>

strokeRoundedLocationUser03 → const List<List>

strokeRoundedLocationUser04 → const List<List>

strokeRoundedLock → const List<List>

strokeRoundedLockComputer → const List<List>

strokeRoundedLocked → const List<List>

strokeRoundedLocker → const List<List>

strokeRoundedLocker01 → const List<List>

strokeRoundedLockKey → const List<List>

strokeRoundedLockPassword → const List<List>

strokeRoundedLockSync01 → const List<List>

strokeRoundedLockSync02 → const List<List>

strokeRoundedLogin01 → const List<List>

strokeRoundedLogin02 → const List<List>

strokeRoundedLogin03 → const List<List>

strokeRoundedLoginCircle01 → const List<List>

strokeRoundedLoginCircle02 → const List<List>

strokeRoundedLoginMethod → const List<List>

strokeRoundedLoginSquare01 → const List<List>

strokeRoundedLoginSquare02 → const List<List>

strokeRoundedLogout01 → const List<List>

strokeRoundedLogout02 → const List<List>

strokeRoundedLogout03 → const List<List>

strokeRoundedLogout04 → const List<List>

strokeRoundedLogout05 → const List<List>

strokeRoundedLogoutCircle01 → const List<List>

strokeRoundedLogoutCircle02 → const List<List>

strokeRoundedLogoutSquare01 → const List<List>

strokeRoundedLogoutSquare02 → const List<List>

strokeRoundedLollipop → const List<List>

strokeRoundedLongitude → const List<List>

strokeRoundedLongSleeveShirt → const List<List>

strokeRoundedLookBottom → const List<List>

strokeRoundedLookLeft → const List<List>

strokeRoundedLookRight → const List<List>

strokeRoundedLookTop → const List<List>

strokeRoundedLoom → const List<List>

strokeRoundedLottiefiles → const List<List>

strokeRoundedLoveKoreanFinger → const List<List>

strokeRoundedLowSignal → const List<List>

strokeRoundedLoyaltyCard → const List<List>

strokeRoundedLuggage01 → const List<List>

strokeRoundedLuggage02 → const List<List>

strokeRoundedLungs → const List<List>

strokeRoundedMachineRobot → const List<List>

strokeRoundedMagicWand01 → const List<List>

strokeRoundedMagicWand02 → const List<List>

strokeRoundedMagicWand03 → const List<List>

strokeRoundedMagicWand04 → const List<List>

strokeRoundedMagicWand05 → const List<List>

strokeRoundedMagnet → const List<List>

strokeRoundedMagnet01 → const List<List>

strokeRoundedMagnet02 → const List<List>

strokeRoundedMail01 → const List<List>

strokeRoundedMail02 → const List<List>

strokeRoundedMailAccount01 → const List<List>

strokeRoundedMailAccount02 → const List<List>

strokeRoundedMailAdd01 → const List<List>

strokeRoundedMailAdd02 → const List<List>

strokeRoundedMailAtSign01 → const List<List>

strokeRoundedMailAtSign02 → const List<List>

strokeRoundedMailBlock01 → const List<List>

strokeRoundedMailBlock02 → const List<List>

strokeRoundedMailbox → const List<List>

strokeRoundedMailbox01 → const List<List>

strokeRoundedMailDownload01 → const List<List>

strokeRoundedMailDownload02 → const List<List>

strokeRoundedMailEdit01 → const List<List>

strokeRoundedMailEdit02 → const List<List>

strokeRoundedMailLock01 → const List<List>

strokeRoundedMailLock02 → const List<List>

strokeRoundedMailLove01 → const List<List>

strokeRoundedMailLove02 → const List<List>

strokeRoundedMailMinus01 → const List<List>

strokeRoundedMailMinus02 → const List<List>

strokeRoundedMailOpen → const List<List>

strokeRoundedMailOpen01 → const List<List>

strokeRoundedMailOpen02 → const List<List>

strokeRoundedMailOpenLove → const List<List>

strokeRoundedMailQuestionMark → const List<List>

strokeRoundedMailReceive01 → const List<List>

strokeRoundedMailReceive02 → const List<List>

strokeRoundedMailRemove01 → const List<List>

strokeRoundedMailRemove02 → const List<List>

strokeRoundedMailReply01 → const List<List>

strokeRoundedMailReply02 → const List<List>

strokeRoundedMailReplyAll01 → const List<List>

strokeRoundedMailReplyAll02 → const List<List>

strokeRoundedMails → const List<List>

strokeRoundedMailSearch01 → const List<List>

strokeRoundedMailSearch02 → const List<List>

strokeRoundedMailSecure01 → const List<List>

strokeRoundedMailSecure02 → const List<List>

strokeRoundedMailSend01 → const List<List>

strokeRoundedMailSend02 → const List<List>

strokeRoundedMailSetting01 → const List<List>

strokeRoundedMailSetting02 → const List<List>

strokeRoundedMailUnlock01 → const List<List>

strokeRoundedMailUnlock02 → const List<List>

strokeRoundedMailUpload01 → const List<List>

strokeRoundedMailUpload02 → const List<List>

strokeRoundedMailValidation01 → const List<List>

strokeRoundedMailValidation02 → const List<List>

strokeRoundedMailVoice01 → const List<List>

strokeRoundedMailVoice02 → const List<List>

strokeRoundedMailWarning → const List<List>

strokeRoundedMale02 → const List<List>

strokeRoundedMaleSymbol → const List<List>

strokeRoundedMan → const List<List>

strokeRoundedManager → const List<List>

strokeRoundedManWoman → const List<List>

strokeRoundedMaping → const List<List>

strokeRoundedMapPin → const List<List>

strokeRoundedMapPinCheck → const List<List>

strokeRoundedMapPinHouse → const List<List>

strokeRoundedMapPinMinus → const List<List>

strokeRoundedMapPinPen → const List<List>

strokeRoundedMapPinPlus → const List<List>

strokeRoundedMapPinpoint01 → const List<List>

strokeRoundedMapPinpoint02 → const List<List>

strokeRoundedMapPinX → const List<List>

strokeRoundedMapPinXInside → const List<List>

strokeRoundedMaps → const List<List>

strokeRoundedMapsCircle01 → const List<List>

strokeRoundedMapsCircle02 → const List<List>

strokeRoundedMapsEditing → const List<List>

strokeRoundedMapsGlobal01 → const List<List>

strokeRoundedMapsGlobal02 → const List<List>

strokeRoundedMapsLocation01 → const List<List>

strokeRoundedMapsLocation02 → const List<List>

strokeRoundedMapsOff → const List<List>

strokeRoundedMapsRefresh → const List<List>

strokeRoundedMapsSearch → const List<List>

strokeRoundedMapsSquare01 → const List<List>

strokeRoundedMapsSquare02 → const List<List>

strokeRoundedMarketAnalysis → const List<List>

strokeRoundedMarketing → const List<List>

strokeRoundedMarketOrder → const List<List>

strokeRoundedMask → const List<List>

strokeRoundedMaskLove → const List<List>

strokeRoundedMaskTheater01 → const List<List>

strokeRoundedMaskTheater02 → const List<List>

strokeRoundedMasterCard → const List<List>

strokeRoundedMastodon → const List<List>

strokeRoundedMatches → const List<List>

strokeRoundedMaterialAndTexture → const List<List>

strokeRoundedMath → const List<List>

strokeRoundedMatrix → const List<List>

strokeRoundedMaximize01 → const List<List>

strokeRoundedMaximize02 → const List<List>

strokeRoundedMaximize03 → const List<List>

strokeRoundedMaximize04 → const List<List>

strokeRoundedMaximizeScreen → const List<List>

strokeRoundedMayanPyramid → const List<List>

strokeRoundedMaze → const List<List>

strokeRoundedMcpServer → const List<List>

strokeRoundedMealScan → const List<List>

strokeRoundedMedal01 → const List<List>

strokeRoundedMedal02 → const List<List>

strokeRoundedMedal03 → const List<List>

strokeRoundedMedal04 → const List<List>

strokeRoundedMedal05 → const List<List>

strokeRoundedMedal06 → const List<List>

strokeRoundedMedal07 → const List<List>

strokeRoundedMedalFirstPlace → const List<List>

strokeRoundedMedalSecondPlace → const List<List>

strokeRoundedMedalThirdPlace → const List<List>

strokeRoundedMedicalFile → const List<List>

strokeRoundedMedicalMask → const List<List>

strokeRoundedMedicine01 → const List<List>

strokeRoundedMedicine02 → const List<List>

strokeRoundedMedicineBottle01 → const List<List>

strokeRoundedMedicineBottle02 → const List<List>

strokeRoundedMedicineSyrup → const List<List>

strokeRoundedMedium → const List<List>

strokeRoundedMediumSignal → const List<List>

strokeRoundedMediumSquare → const List<List>

strokeRoundedMeetingRoom → const List<List>

strokeRoundedMegaphone01 → const List<List>

strokeRoundedMegaphone02 → const List<List>

strokeRoundedMegaphone03 → const List<List>

strokeRoundedMeh → const List<List>

strokeRoundedMemoryStick → const List<List>

strokeRoundedMentor → const List<List>

strokeRoundedMentoring → const List<List>

strokeRoundedMenu01 → const List<List>

strokeRoundedMenu02 → const List<List>

strokeRoundedMenu03 → const List<List>

strokeRoundedMenu04 → const List<List>

strokeRoundedMenu05 → const List<List>

strokeRoundedMenu06 → const List<List>

strokeRoundedMenu07 → const List<List>

strokeRoundedMenu08 → const List<List>

strokeRoundedMenu09 → const List<List>

strokeRoundedMenu10 → const List<List>

strokeRoundedMenu11 → const List<List>

strokeRoundedMenuCircle → const List<List>

strokeRoundedMenuCollapse → const List<List>

strokeRoundedMenuRestaurant → const List<List>

strokeRoundedMenuSquare → const List<List>

strokeRoundedMenuTwoLine → const List<List>

strokeRoundedMessage01 → const List<List>

strokeRoundedMessage02 → const List<List>

strokeRoundedMessageAdd01 → const List<List>

strokeRoundedMessageAdd02 → const List<List>

strokeRoundedMessageBlocked → const List<List>

strokeRoundedMessageCancel01 → const List<List>

strokeRoundedMessageCancel02 → const List<List>

strokeRoundedMessageCircleCode → const List<List>

strokeRoundedMessageCircleReply → const List<List>

strokeRoundedMessageDelay01 → const List<List>

strokeRoundedMessageDelay02 → const List<List>

strokeRoundedMessageDone01 → const List<List>

strokeRoundedMessageDone02 → const List<List>

strokeRoundedMessageDownload01 → const List<List>

strokeRoundedMessageDownload02 → const List<List>

strokeRoundedMessageEdit01 → const List<List>

strokeRoundedMessageEdit02 → const List<List>

strokeRoundedMessageFavourite01 → const List<List>

strokeRoundedMessageFavourite02 → const List<List>

strokeRoundedMessageIncoming01 → const List<List>

strokeRoundedMessageIncoming02 → const List<List>

strokeRoundedMessageLock01 → const List<List>

strokeRoundedMessageLock02 → const List<List>

strokeRoundedMessageMultiple01 → const List<List>

strokeRoundedMessageMultiple02 → const List<List>

strokeRoundedMessageNotification01 → const List<List>

strokeRoundedMessageNotification02 → const List<List>

strokeRoundedMessageOutgoing01 → const List<List>

strokeRoundedMessageOutgoing02 → const List<List>

strokeRoundedMessagePreview01 → const List<List>

strokeRoundedMessagePreview02 → const List<List>

strokeRoundedMessageProgramming → const List<List>

strokeRoundedMessageQuestion → const List<List>

strokeRoundedMessageSearch01 → const List<List>

strokeRoundedMessageSearch02 → const List<List>

strokeRoundedMessageSecure01 → const List<List>

strokeRoundedMessageSecure02 → const List<List>

strokeRoundedMessageSquareCode → const List<List>

strokeRoundedMessageSquareDashed → const List<List>

strokeRoundedMessageSquareDiff → const List<List>

strokeRoundedMessageSquareShare → const List<List>

strokeRoundedMessageTranslate → const List<List>

strokeRoundedMessageUnlock01 → const List<List>

strokeRoundedMessageUnlock02 → const List<List>

strokeRoundedMessageUpload01 → const List<List>

strokeRoundedMessageUpload02 → const List<List>

strokeRoundedMessageUser01 → const List<List>

strokeRoundedMessageUser02 → const List<List>

strokeRoundedMessenger → const List<List>

strokeRoundedMeta → const List<List>

strokeRoundedMetro → const List<List>

strokeRoundedMic01 → const List<List>

strokeRoundedMic02 → const List<List>

strokeRoundedMicOff01 → const List<List>

strokeRoundedMicOff02 → const List<List>

strokeRoundedMicrochip → const List<List>

strokeRoundedMicroscope → const List<List>

strokeRoundedMicrosoft → const List<List>

strokeRoundedMicrosoftAdmin → const List<List>

strokeRoundedMicrowave → const List<List>

strokeRoundedMilkBottle → const List<List>

strokeRoundedMilkCarton → const List<List>

strokeRoundedMilkCoconut → const List<List>

strokeRoundedMilkOat → const List<List>

strokeRoundedMinimize01 → const List<List>

strokeRoundedMinimize02 → const List<List>

strokeRoundedMinimize03 → const List<List>

strokeRoundedMinimize04 → const List<List>

strokeRoundedMinimizeScreen → const List<List>

strokeRoundedMining01 → const List<List>

strokeRoundedMining02 → const List<List>

strokeRoundedMining03 → const List<List>

strokeRoundedMinusPlus01 → const List<List>

strokeRoundedMinusPlus02 → const List<List>

strokeRoundedMinusPlusCircle01 → const List<List>

strokeRoundedMinusPlusCircle02 → const List<List>

strokeRoundedMinusPlusSquare01 → const List<List>

strokeRoundedMinusPlusSquare02 → const List<List>

strokeRoundedMinusSign → const List<List>

strokeRoundedMinusSignCircle → const List<List>

strokeRoundedMinusSignSquare → const List<List>

strokeRoundedMirror → const List<List>

strokeRoundedMirroringScreen → const List<List>

strokeRoundedMistral → const List<List>

strokeRoundedMixer → const List<List>

strokeRoundedMobileNavigator01 → const List<List>

strokeRoundedMobileNavigator02 → const List<List>

strokeRoundedMobileProgramming01 → const List<List>

strokeRoundedMobileProgramming02 → const List<List>

strokeRoundedMobileProtection → const List<List>

strokeRoundedMobileSecurity → const List<List>

strokeRoundedMochi → const List<List>

strokeRoundedModernTv → const List<List>

strokeRoundedModernTv4K → const List<List>

strokeRoundedModernTvIssue → const List<List>

strokeRoundedMolecules → const List<List>

strokeRoundedMollie → const List<List>

strokeRoundedMonas → const List<List>

strokeRoundedMoney01 → const List<List>

strokeRoundedMoney02 → const List<List>

strokeRoundedMoney03 → const List<List>

strokeRoundedMoney04 → const List<List>

strokeRoundedMoneyAdd01 → const List<List>

strokeRoundedMoneyAdd02 → const List<List>

strokeRoundedMoneyBag01 → const List<List>

strokeRoundedMoneyBag02 → const List<List>

strokeRoundedMoneyExchange01 → const List<List>

strokeRoundedMoneyExchange02 → const List<List>

strokeRoundedMoneyExchange03 → const List<List>

strokeRoundedMoneyLock → const List<List>

strokeRoundedMoneyNotFound01 → const List<List>

strokeRoundedMoneyNotFound02 → const List<List>

strokeRoundedMoneyNotFound03 → const List<List>

strokeRoundedMoneyNotFound04 → const List<List>

strokeRoundedMoneyReceive01 → const List<List>

strokeRoundedMoneyReceive02 → const List<List>

strokeRoundedMoneyReceiveCircle → const List<List>

strokeRoundedMoneyReceiveFlow01 → const List<List>

strokeRoundedMoneyReceiveFlow02 → const List<List>

strokeRoundedMoneyReceiveSquare → const List<List>

strokeRoundedMoneyRemove01 → const List<List>

strokeRoundedMoneyRemove02 → const List<List>

strokeRoundedMoneySafe → const List<List>

strokeRoundedMoneySavingJar → const List<List>

strokeRoundedMoneySecurity → const List<List>

strokeRoundedMoneySend01 → const List<List>

strokeRoundedMoneySend02 → const List<List>

strokeRoundedMoneySendCircle → const List<List>

strokeRoundedMoneySendFlow01 → const List<List>

strokeRoundedMoneySendFlow02 → const List<List>

strokeRoundedMoneySendSquare → const List<List>

strokeRoundedMonitorDot → const List<List>

strokeRoundedMonitorPause → const List<List>

strokeRoundedMonitorSpeaker → const List<List>

strokeRoundedMonitorStop → const List<List>

strokeRoundedMonocle → const List<List>

strokeRoundedMonocle01 → const List<List>

strokeRoundedMonster → const List<List>

strokeRoundedMoon → const List<List>

strokeRoundedMoon01 → const List<List>

strokeRoundedMoon02 → const List<List>

strokeRoundedMoonAngledRainZap → const List<List>

strokeRoundedMoonCloud → const List<List>

strokeRoundedMoonCloudAngledRain → const List<List>

strokeRoundedMoonCloudAngledZap → const List<List>

strokeRoundedMoonCloudBigRain → const List<List>

strokeRoundedMoonCloudFastWind → const List<List>

strokeRoundedMoonCloudHailstone → const List<List>

strokeRoundedMoonCloudLittleRain → const List<List>

strokeRoundedMoonCloudLittleSnow → const List<List>

strokeRoundedMoonCloudMidRain → const List<List>

strokeRoundedMoonCloudMidSnow → const List<List>

strokeRoundedMoonCloudSlowWind → const List<List>

strokeRoundedMoonCloudSnow → const List<List>

strokeRoundedMoonEclipse → const List<List>

strokeRoundedMoonFastWind → const List<List>

strokeRoundedMoonLanding → const List<List>

strokeRoundedMoonset → const List<List>

strokeRoundedMoonSlowWind → const List<List>

strokeRoundedMore → const List<List>

strokeRoundedMore01 → const List<List>

strokeRoundedMore02 → const List<List>

strokeRoundedMore03 → const List<List>

strokeRoundedMoreHorizontal → const List<List>

strokeRoundedMoreHorizontalCircle01 → const List<List>

strokeRoundedMoreHorizontalCircle02 → const List<List>

strokeRoundedMoreHorizontalSquare01 → const List<List>

strokeRoundedMoreHorizontalSquare02 → const List<List>

strokeRoundedMoreOrLess → const List<List>

strokeRoundedMoreOrLessCircle → const List<List>

strokeRoundedMoreOrLessSquare → const List<List>

strokeRoundedMoreVertical → const List<List>

strokeRoundedMoreVerticalCircle01 → const List<List>

strokeRoundedMoreVerticalCircle02 → const List<List>

strokeRoundedMoreVerticalSquare01 → const List<List>

strokeRoundedMoreVerticalSquare02 → const List<List>

strokeRoundedMortar → const List<List>

strokeRoundedMortarboard01 → const List<List>

strokeRoundedMortarboard02 → const List<List>

strokeRoundedMosque01 → const List<List>

strokeRoundedMosque02 → const List<List>

strokeRoundedMosque03 → const List<List>

strokeRoundedMosque04 → const List<List>

strokeRoundedMosque05 → const List<List>

strokeRoundedMosqueLocation → const List<List>

strokeRoundedMotion01 → const List<List>

strokeRoundedMotion02 → const List<List>

strokeRoundedMotorbike01 → const List<List>

strokeRoundedMotorbike02 → const List<List>

strokeRoundedMountain → const List<List>

strokeRoundedMouse01 → const List<List>

strokeRoundedMouse02 → const List<List>

strokeRoundedMouse03 → const List<List>

strokeRoundedMouse04 → const List<List>

strokeRoundedMouse05 → const List<List>

strokeRoundedMouse06 → const List<List>

strokeRoundedMouse07 → const List<List>

strokeRoundedMouse08 → const List<List>

strokeRoundedMouse09 → const List<List>

strokeRoundedMouse10 → const List<List>

strokeRoundedMouse11 → const List<List>

strokeRoundedMouse12 → const List<List>

strokeRoundedMouse13 → const List<List>

strokeRoundedMouse14 → const List<List>

strokeRoundedMouse15 → const List<List>

strokeRoundedMouse16 → const List<List>

strokeRoundedMouse17 → const List<List>

strokeRoundedMouse18 → const List<List>

strokeRoundedMouse19 → const List<List>

strokeRoundedMouse20 → const List<List>

strokeRoundedMouse21 → const List<List>

strokeRoundedMouse22 → const List<List>

strokeRoundedMouse23 → const List<List>

strokeRoundedMouseLeftClick01 → const List<List>

strokeRoundedMouseLeftClick02 → const List<List>

strokeRoundedMouseLeftClick03 → const List<List>

strokeRoundedMouseLeftClick04 → const List<List>

strokeRoundedMouseLeftClick05 → const List<List>

strokeRoundedMouseLeftClick06 → const List<List>

strokeRoundedMousePointerOff → const List<List>

strokeRoundedMouseRightClick01 → const List<List>

strokeRoundedMouseRightClick02 → const List<List>

strokeRoundedMouseRightClick03 → const List<List>

strokeRoundedMouseRightClick04 → const List<List>

strokeRoundedMouseRightClick05 → const List<List>

strokeRoundedMouseRightClick06 → const List<List>

strokeRoundedMouseScroll01 → const List<List>

strokeRoundedMouseScroll02 → const List<List>

strokeRoundedMove → const List<List>

strokeRoundedMove01 → const List<List>

strokeRoundedMove02 → const List<List>

strokeRoundedMoveBottom → const List<List>

strokeRoundedMoveLeft → const List<List>

strokeRoundedMoveRight → const List<List>

strokeRoundedMoveTo → const List<List>

strokeRoundedMoveTop → const List<List>

strokeRoundedMp301 → const List<List>

strokeRoundedMp302 → const List<List>

strokeRoundedMp401 → const List<List>

strokeRoundedMp402 → const List<List>

strokeRoundedMuhammad → const List<List>

strokeRoundedMultiplicationSign → const List<List>

strokeRoundedMultiplicationSignCircle → const List<List>

strokeRoundedMultiplicationSignSquare → const List<List>

strokeRoundedMushroom → const List<List>

strokeRoundedMushroom01 → const List<List>

strokeRoundedMusic3 → const List<List>

strokeRoundedMusicNote01 → const List<List>

strokeRoundedMusicNote02 → const List<List>

strokeRoundedMusicNote03 → const List<List>

strokeRoundedMusicNote04 → const List<List>

strokeRoundedMusicNoteSquare01 → const List<List>

strokeRoundedMusicNoteSquare02 → const List<List>

strokeRoundedMuslim → const List<List>

strokeRoundedMute → const List<List>

strokeRoundedMymind → const List<List>

strokeRoundedNanoTechnology → const List<List>

strokeRoundedNapkins01 → const List<List>

strokeRoundedNapkins02 → const List<List>

strokeRoundedNaturalFood → const List<List>

strokeRoundedNavigation → const List<List>

strokeRoundedNavigation01 → const List<List>

strokeRoundedNavigation2 → const List<List>

strokeRoundedNavigation2Off → const List<List>

strokeRoundedNavigation02 → const List<List>

strokeRoundedNavigation03 → const List<List>

strokeRoundedNavigation04 → const List<List>

strokeRoundedNavigation05 → const List<List>

strokeRoundedNavigation06 → const List<List>

strokeRoundedNavigationOff → const List<List>

strokeRoundedNavigator01 → const List<List>

strokeRoundedNavigator02 → const List<List>

strokeRoundedNecklace → const List<List>

strokeRoundedNerd → const List<List>

strokeRoundedNeuralNetwork → const List<List>

strokeRoundedNeutral → const List<List>

strokeRoundedNewJob → const List<List>

strokeRoundedNewOffice → const List<List>

strokeRoundedNewReleases → const List<List>

strokeRoundedNews → const List<List>

strokeRoundedNews01 → const List<List>

strokeRoundedNewTwitter → const List<List>

strokeRoundedNewTwitterEllipse → const List<List>

strokeRoundedNewTwitterRectangle → const List<List>

strokeRoundedNext → const List<List>

strokeRoundedNextWeek → const List<List>

strokeRoundedNfc → const List<List>

strokeRoundedNike → const List<List>

strokeRoundedNineCircle → const List<List>

strokeRoundedNineSquare → const List<List>

strokeRoundedNintendo → const List<List>

strokeRoundedNintendoSwitch → const List<List>

strokeRoundedNiqab → const List<List>

strokeRoundedNodeAdd → const List<List>

strokeRoundedNodeEdit → const List<List>

strokeRoundedNodeMoveDown → const List<List>

strokeRoundedNodeMoveUp → const List<List>

strokeRoundedNodeRemove → const List<List>

strokeRoundedNoInternet → const List<List>

strokeRoundedNoMeetingRoom → const List<List>

strokeRoundedNoodles → const List<List>

strokeRoundedNose → const List<List>

strokeRoundedNoSignal → const List<List>

strokeRoundedNote → const List<List>

strokeRoundedNote01 → const List<List>

strokeRoundedNote02 → const List<List>

strokeRoundedNote03 → const List<List>

strokeRoundedNote04 → const List<List>

strokeRoundedNote05 → const List<List>

strokeRoundedNoteAdd → const List<List>

strokeRoundedNotebook → const List<List>

strokeRoundedNotebook01 → const List<List>

strokeRoundedNotebook02 → const List<List>

strokeRoundedNoteDone → const List<List>

strokeRoundedNoteEdit → const List<List>

strokeRoundedNotepadTextDashed → const List<List>

strokeRoundedNotEqualSign → const List<List>

strokeRoundedNotEqualSignCircle → const List<List>

strokeRoundedNotEqualSignSquare → const List<List>

strokeRoundedNoteRemove → const List<List>

strokeRoundedNotification01 → const List<List>

strokeRoundedNotification02 → const List<List>

strokeRoundedNotification03 → const List<List>

strokeRoundedNotificationBlock01 → const List<List>

strokeRoundedNotificationBlock02 → const List<List>

strokeRoundedNotificationBlock03 → const List<List>

strokeRoundedNotificationBubble → const List<List>

strokeRoundedNotificationCircle → const List<List>

strokeRoundedNotificationOff01 → const List<List>

strokeRoundedNotificationOff02 → const List<List>

strokeRoundedNotificationOff03 → const List<List>

strokeRoundedNotificationSnooze01 → const List<List>

strokeRoundedNotificationSnooze02 → const List<List>

strokeRoundedNotificationSnooze03 → const List<List>

strokeRoundedNotificationSquare → const List<List>

strokeRoundedNotion01 → const List<List>

strokeRoundedNotion02 → const List<List>

strokeRoundedNpm → const List<List>

strokeRoundedNThRoot → const List<List>

strokeRoundedNThRootCircle → const List<List>

strokeRoundedNThRootSquare → const List<List>

strokeRoundedNuclearPower → const List<List>

strokeRoundedNut → const List<List>

strokeRoundedNutOff → const List<List>

strokeRoundedObtuse → const List<List>

strokeRoundedOctagon → const List<List>

strokeRoundedOctagonX → const List<List>

strokeRoundedOctopus → const List<List>

strokeRoundedOffice → const List<List>

strokeRoundedOffice365 → const List<List>

strokeRoundedOfficeChair → const List<List>

strokeRoundedOilBarrel → const List<List>

strokeRoundedOkFinger → const List<List>

strokeRoundedOlympicTorch → const List<List>

strokeRoundedOneCircle → const List<List>

strokeRoundedOneSquare → const List<List>

strokeRoundedOnlineLearning01 → const List<List>

strokeRoundedOnlineLearning02 → const List<List>

strokeRoundedOnlineLearning03 → const List<List>

strokeRoundedOnlineLearning04 → const List<List>

strokeRoundedOpenCaption → const List<List>

strokeRoundedOpenSource → const List<List>

strokeRoundedOption → const List<List>

strokeRoundedOptionsCall → const List<List>

strokeRoundedOrange → const List<List>

strokeRoundedOrbit01 → const List<List>

strokeRoundedOrbit02 → const List<List>

strokeRoundedOrganicFood → const List<List>

strokeRoundedOrientationImageLandscapeToPotrait → const List<List>

strokeRoundedOrientationImagePotraitToLandscape → const List<List>

strokeRoundedOrientationLandscapeToPotrait → const List<List>

strokeRoundedOrientationPotraitToLandscape → const List<List>

strokeRoundedOrigami → const List<List>

strokeRoundedOrthogonalEdge → const List<List>

strokeRoundedOval → const List<List>

strokeRoundedOven → const List<List>

strokeRoundedPackage → const List<List>

strokeRoundedPackage01 → const List<List>

strokeRoundedPackage02 → const List<List>

strokeRoundedPackage03 → const List<List>

strokeRoundedPackageAdd → const List<List>

strokeRoundedPackageAdd01 → const List<List>

strokeRoundedPackageDelivered → const List<List>

strokeRoundedPackageDelivered01 → const List<List>

strokeRoundedPackageDimensions01 → const List<List>

strokeRoundedPackageDimensions02 → const List<List>

strokeRoundedPackageMoving → const List<List>

strokeRoundedPackageMoving01 → const List<List>

strokeRoundedPackageOpen → const List<List>

strokeRoundedPackageOutOfStock → const List<List>

strokeRoundedPackageProcess → const List<List>

strokeRoundedPackageProcess01 → const List<List>

strokeRoundedPackageReceive → const List<List>

strokeRoundedPackageReceive01 → const List<List>

strokeRoundedPackageRemove → const List<List>

strokeRoundedPackageRemove01 → const List<List>

strokeRoundedPackageSearch → const List<List>

strokeRoundedPackageSearch01 → const List<List>

strokeRoundedPackageSent → const List<List>

strokeRoundedPackageSent01 → const List<List>

strokeRoundedPackaging → const List<List>

strokeRoundedPacman01 → const List<List>

strokeRoundedPacman02 → const List<List>

strokeRoundedPaella → const List<List>

strokeRoundedPaintBoard → const List<List>

strokeRoundedPaintBrush01 → const List<List>

strokeRoundedPaintBrush02 → const List<List>

strokeRoundedPaintBrush03 → const List<List>

strokeRoundedPaintBrush04 → const List<List>

strokeRoundedPaintBucket → const List<List>

strokeRoundedPan01 → const List<List>

strokeRoundedPan02 → const List<List>

strokeRoundedPan03 → const List<List>

strokeRoundedPanelBottomClose → const List<List>

strokeRoundedPanelLeft → const List<List>

strokeRoundedPanelLeftClose → const List<List>

strokeRoundedPanelLeftDashed → const List<List>

strokeRoundedPanelLeftOpen → const List<List>

strokeRoundedPanelRight → const List<List>

strokeRoundedPanelRightClose → const List<List>

strokeRoundedPanelRightDashed → const List<List>

strokeRoundedPanelRightOpen → const List<List>

strokeRoundedPanelTopBottomDashed → const List<List>

strokeRoundedParabola01 → const List<List>

strokeRoundedParabola02 → const List<List>

strokeRoundedParabola03 → const List<List>

strokeRoundedParagliding → const List<List>

strokeRoundedParagraph → const List<List>

strokeRoundedParagraphBulletsPoint01 → const List<List>

strokeRoundedParagraphBulletsPoint02 → const List<List>

strokeRoundedParagraphSpacing → const List<List>

strokeRoundedParallelogram → const List<List>

strokeRoundedParkingAreaCircle → const List<List>

strokeRoundedParkingAreaSquare → const List<List>

strokeRoundedParkingMeter → const List<List>

strokeRoundedParty → const List<List>

strokeRoundedPassport → const List<List>

strokeRoundedPassport01 → const List<List>

strokeRoundedPassportExpired → const List<List>

strokeRoundedPassportValid → const List<List>

strokeRoundedPasswordValidation → const List<List>

strokeRoundedPath → const List<List>

strokeRoundedPathfinderCrop → const List<List>

strokeRoundedPathfinderDivide → const List<List>

strokeRoundedPathfinderExclude → const List<List>

strokeRoundedPathfinderIntersect → const List<List>

strokeRoundedPathfinderMerge → const List<List>

strokeRoundedPathfinderMinusBack → const List<List>

strokeRoundedPathfinderMinusFront → const List<List>

strokeRoundedPathfinderOutline → const List<List>

strokeRoundedPathfinderTrim → const List<List>

strokeRoundedPathfinderUnite → const List<List>

strokeRoundedPatient → const List<List>

strokeRoundedPatio → const List<List>

strokeRoundedPause → const List<List>

strokeRoundedPauseCircle → const List<List>

strokeRoundedPavilon → const List<List>

strokeRoundedPayByCheck → const List<List>

strokeRoundedPayment01 → const List<List>

strokeRoundedPayment02 → const List<List>

strokeRoundedPaymentSuccess01 → const List<List>

strokeRoundedPaymentSuccess02 → const List<List>

strokeRoundedPayoneer → const List<List>

strokeRoundedPaypal → const List<List>

strokeRoundedPcCase → const List<List>

strokeRoundedPdf01 → const List<List>

strokeRoundedPdf02 → const List<List>

strokeRoundedPeerToPeer01 → const List<List>

strokeRoundedPeerToPeer02 → const List<List>

strokeRoundedPeerToPeer03 → const List<List>

strokeRoundedPen01 → const List<List>

strokeRoundedPen02 → const List<List>

strokeRoundedPencil → const List<List>

strokeRoundedPencilEdit01 → const List<List>

strokeRoundedPencilEdit02 → const List<List>

strokeRoundedPencilRuler → const List<List>

strokeRoundedPenConnectBluetooth → const List<List>

strokeRoundedPenConnectUsb → const List<List>

strokeRoundedPenConnectWifi → const List<List>

strokeRoundedPendulum → const List<List>

strokeRoundedPensive → const List<List>

strokeRoundedPentagon → const List<List>

strokeRoundedPentagon01 → const List<List>

strokeRoundedPenTool01 → const List<List>

strokeRoundedPenTool02 → const List<List>

strokeRoundedPenTool03 → const List<List>

strokeRoundedPenToolAdd → const List<List>

strokeRoundedPenToolMinus → const List<List>

strokeRoundedPercent → const List<List>

strokeRoundedPercentCircle → const List<List>

strokeRoundedPercentSquare → const List<List>

strokeRoundedPerfume → const List<List>

strokeRoundedPeriscope → const List<List>

strokeRoundedPermanentJob → const List<List>

strokeRoundedPerplexityAi → const List<List>

strokeRoundedPerspective → const List<List>

strokeRoundedPetrolPump → const List<List>

strokeRoundedPexels → const List<List>

strokeRoundedPhilippinePeso → const List<List>

strokeRoundedPhoneArrowDown → const List<List>

strokeRoundedPhoneArrowUp → const List<List>

strokeRoundedPhoneCheck → const List<List>

strokeRoundedPhoneDeveloperMode → const List<List>

strokeRoundedPhoneErase → const List<List>

strokeRoundedPhoneLock → const List<List>

strokeRoundedPhoneOff01 → const List<List>

strokeRoundedPhoneOff02 → const List<List>

strokeRoundedPhp → const List<List>

strokeRoundedPhysics → const List<List>

strokeRoundedPi → const List<List>

strokeRoundedPicasa → const List<List>

strokeRoundedPiCircle → const List<List>

strokeRoundedPickup01 → const List<List>

strokeRoundedPickup02 → const List<List>

strokeRoundedPictureInPictureExit → const List<List>

strokeRoundedPictureInPictureOn → const List<List>

strokeRoundedPie → const List<List>

strokeRoundedPieChart → const List<List>

strokeRoundedPieChart01 → const List<List>

strokeRoundedPieChart02 → const List<List>

strokeRoundedPieChart03 → const List<List>

strokeRoundedPieChart04 → const List<List>

strokeRoundedPieChart05 → const List<List>

strokeRoundedPieChart06 → const List<List>

strokeRoundedPieChart07 → const List<List>

strokeRoundedPieChart08 → const List<List>

strokeRoundedPieChart09 → const List<List>

strokeRoundedPieChartSquare → const List<List>

strokeRoundedPiggyBank → const List<List>

strokeRoundedPill → const List<List>

strokeRoundedPillBottle → const List<List>

strokeRoundedPillOff → const List<List>

strokeRoundedPillsTablet → const List<List>

strokeRoundedPin → const List<List>

strokeRoundedPin02 → const List<List>

strokeRoundedPinCode → const List<List>

strokeRoundedPineTree → const List<List>

strokeRoundedPinLocation01 → const List<List>

strokeRoundedPinLocation02 → const List<List>

strokeRoundedPinLocation03 → const List<List>

strokeRoundedPinOff → const List<List>

strokeRoundedPinterest → const List<List>

strokeRoundedPipeline → const List<List>

strokeRoundedPisaTower → const List<List>

strokeRoundedPiSquare → const List<List>

strokeRoundedPivot → const List<List>

strokeRoundedPizza01 → const List<List>

strokeRoundedPizza02 → const List<List>

strokeRoundedPizza03 → const List<List>

strokeRoundedPizza04 → const List<List>

strokeRoundedPizzaCutter → const List<List>

strokeRoundedPlane → const List<List>

strokeRoundedPlant01 → const List<List>

strokeRoundedPlant02 → const List<List>

strokeRoundedPlant03 → const List<List>

strokeRoundedPlant04 → const List<List>

strokeRoundedPlate → const List<List>

strokeRoundedPlaxo → const List<List>

strokeRoundedPlay → const List<List>

strokeRoundedPlayCircle → const List<List>

strokeRoundedPlayCircle02 → const List<List>

strokeRoundedPlayList → const List<List>

strokeRoundedPlaylist01 → const List<List>

strokeRoundedPlaylist02 → const List<List>

strokeRoundedPlaylist03 → const List<List>

strokeRoundedPlayListAdd → const List<List>

strokeRoundedPlayListFavourite01 → const List<List>

strokeRoundedPlayListFavourite02 → const List<List>

strokeRoundedPlayListMinus → const List<List>

strokeRoundedPlayListRemove → const List<List>

strokeRoundedPlaySquare → const List<List>

strokeRoundedPlayStore → const List<List>

strokeRoundedPlaza → const List<List>

strokeRoundedPlug01 → const List<List>

strokeRoundedPlug02 → const List<List>

strokeRoundedPlugSocket → const List<List>

strokeRoundedPlusMinus → const List<List>

strokeRoundedPlusMinus01 → const List<List>

strokeRoundedPlusMinus02 → const List<List>

strokeRoundedPlusMinus03 → const List<List>

strokeRoundedPlusMinusCircle01 → const List<List>

strokeRoundedPlusMinusCircle02 → const List<List>

strokeRoundedPlusMinusSquare01 → const List<List>

strokeRoundedPlusMinusSquare02 → const List<List>

strokeRoundedPlusSign → const List<List>

strokeRoundedPlusSignCircle → const List<List>

strokeRoundedPlusSignSquare → const List<List>

strokeRoundedPng01 → const List<List>

strokeRoundedPng02 → const List<List>

strokeRoundedPocket → const List<List>

strokeRoundedPocketKnife → const List<List>

strokeRoundedPodcast → const List<List>

strokeRoundedPodium → const List<List>

strokeRoundedPointingLeft01 → const List<List>

strokeRoundedPointingLeft02 → const List<List>

strokeRoundedPointingLeft03 → const List<List>

strokeRoundedPointingLeft04 → const List<List>

strokeRoundedPointingLeft05 → const List<List>

strokeRoundedPointingLeft06 → const List<List>

strokeRoundedPointingLeft07 → const List<List>

strokeRoundedPointingLeft08 → const List<List>

strokeRoundedPointingRight01 → const List<List>

strokeRoundedPointingRight02 → const List<List>

strokeRoundedPointingRight03 → const List<List>

strokeRoundedPointingRight04 → const List<List>

strokeRoundedPointingRight05 → const List<List>

strokeRoundedPointingRight06 → const List<List>

strokeRoundedPointingRight07 → const List<List>

strokeRoundedPointingRight08 → const List<List>

strokeRoundedPokeball → const List<List>

strokeRoundedPokemon → const List<List>

strokeRoundedPoliceBadge → const List<List>

strokeRoundedPoliceCap → const List<List>

strokeRoundedPoliceCar → const List<List>

strokeRoundedPoliceStation → const List<List>

strokeRoundedPolicy → const List<List>

strokeRoundedPolygon → const List<List>

strokeRoundedPolyTank → const List<List>

strokeRoundedPool → const List<List>

strokeRoundedPoolTable → const List<List>

strokeRoundedPoop → const List<List>

strokeRoundedPopcorn → const List<List>

strokeRoundedPopsicle → const List<List>

strokeRoundedPot01 → const List<List>

strokeRoundedPot02 → const List<List>

strokeRoundedPotion → const List<List>

strokeRoundedPound → const List<List>

strokeRoundedPoundCircle → const List<List>

strokeRoundedPoundReceive → const List<List>

strokeRoundedPoundSend → const List<List>

strokeRoundedPoundSquare → const List<List>

strokeRoundedPower → const List<List>

strokeRoundedPowerOff → const List<List>

strokeRoundedPowerService → const List<List>

strokeRoundedPowerSocket01 → const List<List>

strokeRoundedPowerSocket02 → const List<List>

strokeRoundedPpt01 → const List<List>

strokeRoundedPpt02 → const List<List>

strokeRoundedPrawn → const List<List>

strokeRoundedPrayerRug01 → const List<List>

strokeRoundedPrayerRug02 → const List<List>

strokeRoundedPreferenceHorizontal → const List<List>

strokeRoundedPreferenceVertical → const List<List>

strokeRoundedPrescription → const List<List>

strokeRoundedPrescriptions → const List<List>

strokeRoundedPresentation01 → const List<List>

strokeRoundedPresentation02 → const List<List>

strokeRoundedPresentation03 → const List<List>

strokeRoundedPresentation04 → const List<List>

strokeRoundedPresentation05 → const List<List>

strokeRoundedPresentation06 → const List<List>

strokeRoundedPresentation07 → const List<List>

strokeRoundedPresentationBarChart01 → const List<List>

strokeRoundedPresentationBarChart02 → const List<List>

strokeRoundedPresentationLineChart01 → const List<List>

strokeRoundedPresentationLineChart02 → const List<List>

strokeRoundedPresentationOnline → const List<List>

strokeRoundedPresentationPodium → const List<List>

strokeRoundedPrevious → const List<List>

strokeRoundedPrinter → const List<List>

strokeRoundedPrinter3d → const List<List>

strokeRoundedPrinterCheck → const List<List>

strokeRoundedPrinterOff → const List<List>

strokeRoundedPrinterX → const List<List>

strokeRoundedPrism → const List<List>

strokeRoundedPrism01 → const List<List>

strokeRoundedPrison → const List<List>

strokeRoundedPrisoner → const List<List>

strokeRoundedPrisonGuard → const List<List>

strokeRoundedProductLoading → const List<List>

strokeRoundedProfile → const List<List>

strokeRoundedProfile02 → const List<List>

strokeRoundedProfit → const List<List>

strokeRoundedProgrammingFlag → const List<List>

strokeRoundedProgress → const List<List>

strokeRoundedProgress01 → const List<List>

strokeRoundedProgress02 → const List<List>

strokeRoundedProgress03 → const List<List>

strokeRoundedProgress04 → const List<List>

strokeRoundedProjector → const List<List>

strokeRoundedProjector01 → const List<List>

strokeRoundedPromotion → const List<List>

strokeRoundedPropertyAdd → const List<List>

strokeRoundedPropertyDelete → const List<List>

strokeRoundedPropertyEdit → const List<List>

strokeRoundedPropertyNew → const List<List>

strokeRoundedPropertySearch → const List<List>

strokeRoundedPropertyView → const List<List>

strokeRoundedProportions → const List<List>

strokeRoundedProtectionMask → const List<List>

strokeRoundedPulley → const List<List>

strokeRoundedPulse01 → const List<List>

strokeRoundedPulse02 → const List<List>

strokeRoundedPulseRectangle01 → const List<List>

strokeRoundedPulseRectangle02 → const List<List>

strokeRoundedPumpkin → const List<List>

strokeRoundedPunch → const List<List>

strokeRoundedPunchingBall01 → const List<List>

strokeRoundedPunchingBall02 → const List<List>

strokeRoundedPurse → const List<List>

strokeRoundedPurse01 → const List<List>

strokeRoundedPushUpBar → const List<List>

strokeRoundedPuzzle → const List<List>

strokeRoundedPyramid → const List<List>

strokeRoundedPyramidMaslowo → const List<List>

strokeRoundedPyramidStructure01 → const List<List>

strokeRoundedPyramidStructure02 → const List<List>

strokeRoundedPython → const List<List>

strokeRoundedQqPlot → const List<List>

strokeRoundedQrCode → const List<List>

strokeRoundedQrCode01 → const List<List>

strokeRoundedQrCodeScan → const List<List>

strokeRoundedQuestion → const List<List>

strokeRoundedQueue01 → const List<List>

strokeRoundedQueue02 → const List<List>

strokeRoundedQuillWrite01 → const List<List>

strokeRoundedQuillWrite02 → const List<List>

strokeRoundedQuiz01 → const List<List>

strokeRoundedQuiz02 → const List<List>

strokeRoundedQuiz03 → const List<List>

strokeRoundedQuiz04 → const List<List>

strokeRoundedQuiz05 → const List<List>

strokeRoundedQuora → const List<List>

strokeRoundedQuoteDown → const List<List>

strokeRoundedQuoteDownCircle → const List<List>

strokeRoundedQuoteDownSquare → const List<List>

strokeRoundedQuotes → const List<List>

strokeRoundedQuoteUp → const List<List>

strokeRoundedQuoteUpCircle → const List<List>

strokeRoundedQuoteUpSquare → const List<List>

strokeRoundedQuran01 → const List<List>

strokeRoundedQuran02 → const List<List>

strokeRoundedQuran03 → const List<List>

strokeRoundedQwen → const List<List>

strokeRoundedRacingFlag → const List<List>

strokeRoundedRadar01 → const List<List>

strokeRoundedRadar02 → const List<List>

strokeRoundedRadar03 → const List<List>

strokeRoundedRadial → const List<List>

strokeRoundedRadiation → const List<List>

strokeRoundedRadio → const List<List>

strokeRoundedRadio01 → const List<List>

strokeRoundedRadio02 → const List<List>

strokeRoundedRadioactiveAlert → const List<List>

strokeRoundedRadioButton → const List<List>

strokeRoundedRadius → const List<List>

strokeRoundedRailSymbol → const List<List>

strokeRoundedRain → const List<List>

strokeRoundedRainbow → const List<List>

strokeRoundedRainDoubleDrop → const List<List>

strokeRoundedRainDrop → const List<List>

strokeRoundedRamadhan01 → const List<List>

strokeRoundedRamadhan02 → const List<List>

strokeRoundedRamadhanMonth → const List<List>

strokeRoundedRamMemory → const List<List>

strokeRoundedRanking → const List<List>

strokeRoundedRar01 → const List<List>

strokeRoundedRar02 → const List<List>

strokeRoundedRatio → const List<List>

strokeRoundedRaw01 → const List<List>

strokeRoundedRaw02 → const List<List>

strokeRoundedRe → const List<List>

strokeRoundedReact → const List<List>

strokeRoundedRealEstate01 → const List<List>

strokeRoundedRealEstate02 → const List<List>

strokeRoundedReceiptCent → const List<List>

strokeRoundedReceiptDollar → const List<List>

strokeRoundedReceiptEuro → const List<List>

strokeRoundedReceiptIndianRupee → const List<List>

strokeRoundedReceiptJapaneseYen → const List<List>

strokeRoundedReceiptPoundSterling → const List<List>

strokeRoundedReceiptRussianRuble → const List<List>

strokeRoundedReceiptSwissFranc → const List<List>

strokeRoundedReceiptText → const List<List>

strokeRoundedReceiptTurkishLira → const List<List>

strokeRoundedRecord → const List<List>

strokeRoundedRecoveryMail → const List<List>

strokeRoundedRectangleCircle → const List<List>

strokeRoundedRectangular → const List<List>

strokeRoundedRectangular01 → const List<List>

strokeRoundedRecycle01 → const List<List>

strokeRoundedRecycle02 → const List<List>

strokeRoundedRecycle03 → const List<List>

strokeRoundedReddit → const List<List>

strokeRoundedRedo → const List<List>

strokeRoundedRedo02 → const List<List>

strokeRoundedRedo03 → const List<List>

strokeRoundedRedoDot → const List<List>

strokeRoundedReduceParagraph → const List<List>

strokeRoundedReflex → const List<List>

strokeRoundedRefresh → const List<List>

strokeRoundedRefresh01 → const List<List>

strokeRoundedRefresh03 → const List<List>

strokeRoundedRefresh04 → const List<List>

strokeRoundedRefreshCwOff → const List<List>

strokeRoundedRefreshDot → const List<List>

strokeRoundedRefrigerator → const List<List>

strokeRoundedRegex → const List<List>

strokeRoundedRegister → const List<List>

strokeRoundedRegistered → const List<List>

strokeRoundedRelieved01 → const List<List>

strokeRoundedRelieved02 → const List<List>

strokeRoundedReload → const List<List>

strokeRoundedReminder → const List<List>

strokeRoundedRemoteControl → const List<List>

strokeRoundedRemove01 → const List<List>

strokeRoundedRemove02 → const List<List>

strokeRoundedRemoveCircle → const List<List>

strokeRoundedRemoveCircleHalfDot → const List<List>

strokeRoundedRemoveFemale → const List<List>

strokeRoundedRemoveMale → const List<List>

strokeRoundedRemovePi → const List<List>

strokeRoundedRemoveSquare → const List<List>

strokeRoundedRenewableEnergy → const List<List>

strokeRoundedRenewableEnergy01 → const List<List>

strokeRoundedRepair → const List<List>

strokeRoundedRepeat → const List<List>

strokeRoundedRepeatOff → const List<List>

strokeRoundedRepeatOne01 → const List<List>

strokeRoundedRepeatOne02 → const List<List>

strokeRoundedReplace → const List<List>

strokeRoundedReplaceAll → const List<List>

strokeRoundedReplay → const List<List>

strokeRoundedReplit → const List<List>

strokeRoundedRepository → const List<List>

strokeRoundedRepost → const List<List>

strokeRoundedResetPassword → const List<List>

strokeRoundedResize01 → const List<List>

strokeRoundedResize02 → const List<List>

strokeRoundedResizeField → const List<List>

strokeRoundedResizeFieldRectangle → const List<List>

strokeRoundedResourcesAdd → const List<List>

strokeRoundedResourcesRemove → const List<List>

strokeRoundedRestaurant → const List<List>

strokeRoundedRestaurant01 → const List<List>

strokeRoundedRestaurant02 → const List<List>

strokeRoundedRestaurant03 → const List<List>

strokeRoundedRestaurantTable → const List<List>

strokeRoundedRestoreBin → const List<List>

strokeRoundedReturnRequest → const List<List>

strokeRoundedReverseWithdrawal01 → const List<List>

strokeRoundedReverseWithdrawal02 → const List<List>

strokeRoundedRhombus → const List<List>

strokeRoundedRhombus01 → const List<List>

strokeRoundedRibbon → const List<List>

strokeRoundedRiceBowl01 → const List<List>

strokeRoundedRiceBowl02 → const List<List>

strokeRoundedRightAngle → const List<List>

strokeRoundedRightToLeftBlockQuote → const List<List>

strokeRoundedRightToLeftListBullet → const List<List>

strokeRoundedRightToLeftListDash → const List<List>

strokeRoundedRightToLeftListNumber → const List<List>

strokeRoundedRightToLeftListTriangle → const List<List>

strokeRoundedRightTriangle → const List<List>

strokeRoundedRipple → const List<List>

strokeRoundedRiyal → const List<List>

strokeRoundedRiyalRectangle → const List<List>

strokeRoundedRoad → const List<List>

strokeRoundedRoad01 → const List<List>

strokeRoundedRoad02 → const List<List>

strokeRoundedRoadLocation01 → const List<List>

strokeRoundedRoadLocation02 → const List<List>

strokeRoundedRoadWayside → const List<List>

strokeRoundedRobot01 → const List<List>

strokeRoundedRobot02 → const List<List>

strokeRoundedRobotic → const List<List>

strokeRoundedRocket → const List<List>

strokeRoundedRocket01 → const List<List>

strokeRoundedRocket02 → const List<List>

strokeRoundedRockingChair → const List<List>

strokeRoundedRockingHorse → const List<List>

strokeRoundedRollerCoaster → const List<List>

strokeRoundedRollerSkate → const List<List>

strokeRoundedRollingPin → const List<List>

strokeRoundedRoot1stBracket → const List<List>

strokeRoundedRoot1stBrecket → const List<List>

strokeRoundedRoot01 → const List<List>

strokeRoundedRoot2ndBracket → const List<List>

strokeRoundedRoot2ndBrecket → const List<List>

strokeRoundedRoot02 → const List<List>

strokeRoundedRoot3rdBracket → const List<List>

strokeRoundedRoot3rdBrecket → const List<List>

strokeRoundedRootCircle → const List<List>

strokeRoundedRose → const List<List>

strokeRoundedRotate01 → const List<List>

strokeRoundedRotate02 → const List<List>

strokeRoundedRotate360 → const List<List>

strokeRoundedRotateBottomLeft → const List<List>

strokeRoundedRotateBottomRight → const List<List>

strokeRoundedRotateCcwSquare → const List<List>

strokeRoundedRotateClockwise → const List<List>

strokeRoundedRotateCrop → const List<List>

strokeRoundedRotateCwSquare → const List<List>

strokeRoundedRotateLeft01 → const List<List>

strokeRoundedRotateLeft02 → const List<List>

strokeRoundedRotateLeft03 → const List<List>

strokeRoundedRotateLeft04 → const List<List>

strokeRoundedRotateLeft05 → const List<List>

strokeRoundedRotateLeft06 → const List<List>

strokeRoundedRotateRight01 → const List<List>

strokeRoundedRotateRight02 → const List<List>

strokeRoundedRotateRight03 → const List<List>

strokeRoundedRotateRight04 → const List<List>

strokeRoundedRotateRight05 → const List<List>

strokeRoundedRotateRight06 → const List<List>

strokeRoundedRotateSquare → const List<List>

strokeRoundedRotateTopLeft → const List<List>

strokeRoundedRotateTopRight → const List<List>

strokeRoundedRoute01 → const List<List>

strokeRoundedRoute02 → const List<List>

strokeRoundedRoute03 → const List<List>

strokeRoundedRouteBlock → const List<List>

strokeRoundedRouter → const List<List>

strokeRoundedRouter01 → const List<List>

strokeRoundedRouter02 → const List<List>

strokeRoundedRowDelete → const List<List>

strokeRoundedRowInsert → const List<List>

strokeRoundedRss → const List<List>

strokeRoundedRssConnected01 → const List<List>

strokeRoundedRssConnected02 → const List<List>

strokeRoundedRssError → const List<List>

strokeRoundedRssLocked → const List<List>

strokeRoundedRssUnlocked → const List<List>

strokeRoundedRubberDuck → const List<List>

strokeRoundedRubElHizb → const List<List>

strokeRoundedRubiksCube → const List<List>

strokeRoundedRuku → const List<List>

strokeRoundedRuler → const List<List>

strokeRoundedRunningShoes → const List<List>

strokeRoundedRupee → const List<List>

strokeRoundedRupeeCircle → const List<List>

strokeRoundedRupeeShield → const List<List>

strokeRoundedRupeeSquare → const List<List>

strokeRoundedRussianRuble → const List<List>

strokeRoundedSad01 → const List<List>

strokeRoundedSad02 → const List<List>

strokeRoundedSadDizzy → const List<List>

strokeRoundedSafari → const List<List>

strokeRoundedSafe → const List<List>

strokeRoundedSafeBox → const List<List>

strokeRoundedSafeDelivery01 → const List<List>

strokeRoundedSafeDelivery02 → const List<List>

strokeRoundedSafetyPin01 → const List<List>

strokeRoundedSafetyPin02 → const List<List>

strokeRoundedSailboatCoastal → const List<List>

strokeRoundedSailboatOffshore → const List<List>

strokeRoundedSakura → const List<List>

strokeRoundedSalad → const List<List>

strokeRoundedSalah → const List<List>

strokeRoundedSalahTime → const List<List>

strokeRoundedSaleTag01 → const List<List>

strokeRoundedSaleTag02 → const List<List>

strokeRoundedSandals → const List<List>

strokeRoundedSatellite → const List<List>

strokeRoundedSatellite01 → const List<List>

strokeRoundedSatellite02 → const List<List>

strokeRoundedSatellite03 → const List<List>

strokeRoundedSaturn → const List<List>

strokeRoundedSaturn01 → const List<List>

strokeRoundedSaturn02 → const List<List>

strokeRoundedSaudiRiyal → const List<List>

strokeRoundedSausage → const List<List>

strokeRoundedSave → const List<List>

strokeRoundedSaveAll → const List<List>

strokeRoundedSaveEnergy01 → const List<List>

strokeRoundedSaveEnergy02 → const List<List>

strokeRoundedSaveMoneyDollar → const List<List>

strokeRoundedSaveMoneyEuro → const List<List>

strokeRoundedSaveMoneyPound → const List<List>

strokeRoundedSaveMoneyYen → const List<List>

strokeRoundedSaveOff → const List<List>

strokeRoundedSavings → const List<List>

strokeRoundedScan → const List<List>

strokeRoundedScanEye → const List<List>

strokeRoundedScanHeart → const List<List>

strokeRoundedScanImage → const List<List>

strokeRoundedScheme → const List<List>

strokeRoundedSchool → const List<List>

strokeRoundedSchool01 → const List<List>

strokeRoundedSchoolBell01 → const List<List>

strokeRoundedSchoolBell02 → const List<List>

strokeRoundedSchoolBus → const List<List>

strokeRoundedSchoolReportCard → const List<List>

strokeRoundedSchoolTie → const List<List>

strokeRoundedScissor → const List<List>

strokeRoundedScissor01 → const List<List>

strokeRoundedScissorRectangle → const List<List>

strokeRoundedScooter01 → const List<List>

strokeRoundedScooter02 → const List<List>

strokeRoundedScooter03 → const List<List>

strokeRoundedScooter04 → const List<List>

strokeRoundedScooterElectric → const List<List>

strokeRoundedScratchCard → const List<List>

strokeRoundedScreenAddToHome → const List<List>

strokeRoundedScreenAddToHome02 → const List<List>

strokeRoundedScreenLockRotation → const List<List>

strokeRoundedScreenRotation → const List<List>

strokeRoundedScribd → const List<List>

strokeRoundedScroll → const List<List>

strokeRoundedScroll01 → const List<List>

strokeRoundedScrollHorizontal → const List<List>

strokeRoundedScrollVertical → const List<List>

strokeRoundedSdCard → const List<List>

strokeRoundedSeal → const List<List>

strokeRoundedSearch01 → const List<List>

strokeRoundedSearch02 → const List<List>

strokeRoundedSearchAdd → const List<List>

strokeRoundedSearchArea → const List<List>

strokeRoundedSearchCircle → const List<List>

strokeRoundedSearchCode → const List<List>

strokeRoundedSearchDollar → const List<List>

strokeRoundedSearchFocus → const List<List>

strokeRoundedSearching → const List<List>

strokeRoundedSearchList01 → const List<List>

strokeRoundedSearchList02 → const List<List>

strokeRoundedSearchMinus → const List<List>

strokeRoundedSearchRemove → const List<List>

strokeRoundedSearchReplace → const List<List>

strokeRoundedSearchSquare → const List<List>

strokeRoundedSearchVisual → const List<List>

strokeRoundedSeatSelector → const List<List>

strokeRoundedSection → const List<List>

strokeRoundedSecuredNetwork → const List<List>

strokeRoundedSecurity → const List<List>

strokeRoundedSecurityBlock → const List<List>

strokeRoundedSecurityCheck → const List<List>

strokeRoundedSecurityKeyUsb → const List<List>

strokeRoundedSecurityLock → const List<List>

strokeRoundedSecurityPassword → const List<List>

strokeRoundedSecurityValidation → const List<List>

strokeRoundedSecurityWarning → const List<List>

strokeRoundedSecurityWifi → const List<List>

strokeRoundedSeesaw → const List<List>

strokeRoundedSegment → const List<List>

strokeRoundedSelect01 → const List<List>

strokeRoundedSelect02 → const List<List>

strokeRoundedSelfTransfer → const List<List>

strokeRoundedSemiTruck → const List<List>

strokeRoundedSendingOrder → const List<List>

strokeRoundedSendToBack → const List<List>

strokeRoundedSendToMobile → const List<List>

strokeRoundedSendToMobile02 → const List<List>

strokeRoundedSenseless → const List<List>

strokeRoundedSent → const List<List>

strokeRoundedSent02 → const List<List>

strokeRoundedSeo → const List<List>

strokeRoundedSeparatorHorizontal → const List<List>

strokeRoundedServerStack01 → const List<List>

strokeRoundedServerStack02 → const List<List>

strokeRoundedServerStack03 → const List<List>

strokeRoundedService → const List<List>

strokeRoundedServingFood → const List<List>

strokeRoundedSetting06 → const List<List>

strokeRoundedSetting07 → const List<List>

strokeRoundedSettingDone01 → const List<List>

strokeRoundedSettingDone02 → const List<List>

strokeRoundedSettingDone03 → const List<List>

strokeRoundedSettingDone04 → const List<List>

strokeRoundedSettingError03 → const List<List>

strokeRoundedSettingError04 → const List<List>

strokeRoundedSettings01 → const List<List>

strokeRoundedSettings02 → const List<List>

strokeRoundedSettings03 → const List<List>

strokeRoundedSettings04 → const List<List>

strokeRoundedSettings05 → const List<List>

strokeRoundedSettingsError01 → const List<List>

strokeRoundedSettingsError02 → const List<List>

strokeRoundedSetup01 → const List<List>

strokeRoundedSetup02 → const List<List>

strokeRoundedSevenCircle → const List<List>

strokeRoundedSevenSquare → const List<List>

strokeRoundedShadcn → const List<List>

strokeRoundedShadcnSquare → const List<List>

strokeRoundedShaka01 → const List<List>

strokeRoundedShaka02 → const List<List>

strokeRoundedShaka03 → const List<List>

strokeRoundedShaka04 → const List<List>

strokeRoundedShampoo → const List<List>

strokeRoundedShapeCollection → const List<List>

strokeRoundedShapes → const List<List>

strokeRoundedShapes01 → const List<List>

strokeRoundedShare01 → const List<List>

strokeRoundedShare02 → const List<List>

strokeRoundedShare03 → const List<List>

strokeRoundedShare04 → const List<List>

strokeRoundedShare05 → const List<List>

strokeRoundedShare06 → const List<List>

strokeRoundedShare07 → const List<List>

strokeRoundedShare08 → const List<List>

strokeRoundedSharedDrive → const List<List>

strokeRoundedSharedWifi → const List<List>

strokeRoundedShareKnowledge → const List<List>

strokeRoundedShareLocation01 → const List<List>

strokeRoundedShareLocation02 → const List<List>

strokeRoundedSharing → const List<List>

strokeRoundedShell → const List<List>

strokeRoundedShellfish → const List<List>

strokeRoundedSheriff01 → const List<List>

strokeRoundedSheriff02 → const List<List>

strokeRoundedShield01 → const List<List>

strokeRoundedShield02 → const List<List>

strokeRoundedShieldBan → const List<List>

strokeRoundedShieldBlockchain → const List<List>

strokeRoundedShieldEnergy → const List<List>

strokeRoundedShieldHalf → const List<List>

strokeRoundedShieldKey → const List<List>

strokeRoundedShieldMinus → const List<List>

strokeRoundedShieldPlus → const List<List>

strokeRoundedShieldQuestionMark → const List<List>

strokeRoundedShieldUser → const List<List>

strokeRoundedShipmentTracking → const List<List>

strokeRoundedShippingCenter → const List<List>

strokeRoundedShippingLoading → const List<List>

strokeRoundedShippingTruck01 → const List<List>

strokeRoundedShippingTruck02 → const List<List>

strokeRoundedShirt01 → const List<List>

strokeRoundedShocked → const List<List>

strokeRoundedShopify → const List<List>

strokeRoundedShoppingBag01 → const List<List>

strokeRoundedShoppingBag02 → const List<List>

strokeRoundedShoppingBag03 → const List<List>

strokeRoundedShoppingBagAdd → const List<List>

strokeRoundedShoppingBagCheck → const List<List>

strokeRoundedShoppingBagFavorite → const List<List>

strokeRoundedShoppingBagRemove → const List<List>

strokeRoundedShoppingBasket01 → const List<List>

strokeRoundedShoppingBasket02 → const List<List>

strokeRoundedShoppingBasket03 → const List<List>

strokeRoundedShoppingBasketAdd01 → const List<List>

strokeRoundedShoppingBasketAdd02 → const List<List>

strokeRoundedShoppingBasketAdd03 → const List<List>

strokeRoundedShoppingBasketCheckIn01 → const List<List>

strokeRoundedShoppingBasketCheckIn02 → const List<List>

strokeRoundedShoppingBasketCheckIn03 → const List<List>

strokeRoundedShoppingBasketCheckOut01 → const List<List>

strokeRoundedShoppingBasketCheckOut02 → const List<List>

strokeRoundedShoppingBasketCheckOut03 → const List<List>

strokeRoundedShoppingBasketDone01 → const List<List>

strokeRoundedShoppingBasketDone02 → const List<List>

strokeRoundedShoppingBasketDone03 → const List<List>

strokeRoundedShoppingBasketFavorite01 → const List<List>

strokeRoundedShoppingBasketFavorite02 → const List<List>

strokeRoundedShoppingBasketFavorite03 → const List<List>

strokeRoundedShoppingBasketRemove01 → const List<List>

strokeRoundedShoppingBasketRemove02 → const List<List>

strokeRoundedShoppingBasketRemove03 → const List<List>

strokeRoundedShoppingBasketSecure01 → const List<List>

strokeRoundedShoppingBasketSecure02 → const List<List>

strokeRoundedShoppingBasketSecure03 → const List<List>

strokeRoundedShoppingCart01 → const List<List>

strokeRoundedShoppingCart02 → const List<List>

strokeRoundedShoppingCartAdd01 → const List<List>

strokeRoundedShoppingCartAdd02 → const List<List>

strokeRoundedShoppingCartCheck01 → const List<List>

strokeRoundedShoppingCartCheck02 → const List<List>

strokeRoundedShoppingCartCheckIn01 → const List<List>

strokeRoundedShoppingCartCheckIn02 → const List<List>

strokeRoundedShoppingCartCheckOut01 → const List<List>

strokeRoundedShoppingCartCheckOut02 → const List<List>

strokeRoundedShoppingCartFavorite01 → const List<List>

strokeRoundedShoppingCartFavorite02 → const List<List>

strokeRoundedShoppingCartRemove01 → const List<List>

strokeRoundedShoppingCartRemove02 → const List<List>

strokeRoundedShopSign → const List<List>

strokeRoundedShortsPants → const List<List>

strokeRoundedShoulder → const List<List>

strokeRoundedShovel → const List<List>

strokeRoundedShowerHead → const List<List>

strokeRoundedShrinkDot → const List<List>

strokeRoundedShuffle → const List<List>

strokeRoundedShuffleSquare → const List<List>

strokeRoundedShutDown → const List<List>

strokeRoundedShutterstock → const List<List>

strokeRoundedSidebarBottom → const List<List>

strokeRoundedSidebarLeft → const List<List>

strokeRoundedSidebarLeft01 → const List<List>

strokeRoundedSidebarRight → const List<List>

strokeRoundedSidebarRight01 → const List<List>

strokeRoundedSidebarTop → const List<List>

strokeRoundedSignal → const List<List>

strokeRoundedSignalFull01 → const List<List>

strokeRoundedSignalFull02 → const List<List>

strokeRoundedSignalLow01 → const List<List>

strokeRoundedSignalLow02 → const List<List>

strokeRoundedSignalLowMedium → const List<List>

strokeRoundedSignalMedium01 → const List<List>

strokeRoundedSignalMedium02 → const List<List>

strokeRoundedSignalNo01 → const List<List>

strokeRoundedSignalNo02 → const List<List>

strokeRoundedSignature → const List<List>

strokeRoundedSignLanguageC → const List<List>

strokeRoundedSilence → const List<List>

strokeRoundedSimcard01 → const List<List>

strokeRoundedSimcard02 → const List<List>

strokeRoundedSimcardDual → const List<List>

strokeRoundedSin → const List<List>

strokeRoundedSine01 → const List<List>

strokeRoundedSine02 → const List<List>

strokeRoundedSingleFire → const List<List>

strokeRoundedSingLeft → const List<List>

strokeRoundedSingRight → const List<List>

strokeRoundedSink01 → const List<List>

strokeRoundedSink02 → const List<List>

strokeRoundedSiri → const List<List>

strokeRoundedSiriNew → const List<List>

strokeRoundedSixCircle → const List<List>

strokeRoundedSixSquare → const List<List>

strokeRoundedSketch → const List<List>

strokeRoundedSkew → const List<List>

strokeRoundedSki → const List<List>

strokeRoundedSkippingRope → const List<List>

strokeRoundedSkool → const List<List>

strokeRoundedSkull → const List<List>

strokeRoundedSkype → const List<List>

strokeRoundedSlack → const List<List>

strokeRoundedSleeping → const List<List>

strokeRoundedSleeveless → const List<List>

strokeRoundedSlide → const List<List>

strokeRoundedSlidersHorizontal → const List<List>

strokeRoundedSlidersVertical → const List<List>

strokeRoundedSlideshare → const List<List>

strokeRoundedSlowWinds → const List<List>

strokeRoundedSmart → const List<List>

strokeRoundedSmartAc → const List<List>

strokeRoundedSmartPhone01 → const List<List>

strokeRoundedSmartPhone02 → const List<List>

strokeRoundedSmartPhone03 → const List<List>

strokeRoundedSmartPhone04 → const List<List>

strokeRoundedSmartphoneCharging → const List<List>

strokeRoundedSmartPhoneLandscape → const List<List>

strokeRoundedSmartPhoneLandscape02 → const List<List>

strokeRoundedSmartphoneLostWifi → const List<List>

strokeRoundedSmartphoneNfc → const List<List>

strokeRoundedSmartphoneWifi → const List<List>

strokeRoundedSmartWatch01 → const List<List>

strokeRoundedSmartWatch02 → const List<List>

strokeRoundedSmartWatch03 → const List<List>

strokeRoundedSmartWatch04 → const List<List>

strokeRoundedSmile → const List<List>

strokeRoundedSmileDizzy → const List<List>

strokeRoundedSmilePlus → const List<List>

strokeRoundedSmsCode → const List<List>

strokeRoundedSnail → const List<List>

strokeRoundedSnapchat → const List<List>

strokeRoundedSnow → const List<List>

strokeRoundedSocks → const List<List>

strokeRoundedSodaCan → const List<List>

strokeRoundedSofa01 → const List<List>

strokeRoundedSofa02 → const List<List>

strokeRoundedSofa03 → const List<List>

strokeRoundedSofaSingle → const List<List>

strokeRoundedSoftDrink01 → const List<List>

strokeRoundedSoftDrink02 → const List<List>

strokeRoundedSoftware → const List<List>

strokeRoundedSoftwareLicense → const List<List>

strokeRoundedSoftwareUninstall → const List<List>

strokeRoundedSoilMoistureField → const List<List>

strokeRoundedSoilMoistureGlobal → const List<List>

strokeRoundedSoilTemperatureField → const List<List>

strokeRoundedSoilTemperatureGlobal → const List<List>

strokeRoundedSolarEnergy → const List<List>

strokeRoundedSolarPanel01 → const List<List>

strokeRoundedSolarPanel02 → const List<List>

strokeRoundedSolarPanel03 → const List<List>

strokeRoundedSolarPanel04 → const List<List>

strokeRoundedSolarPanel05 → const List<List>

strokeRoundedSolarPower → const List<List>

strokeRoundedSolarSystem → const List<List>

strokeRoundedSolarSystem01 → const List<List>

strokeRoundedSolidLine01 → const List<List>

strokeRoundedSolidLine02 → const List<List>

strokeRoundedSortByDown01 → const List<List>

strokeRoundedSortByDown02 → const List<List>

strokeRoundedSortByUp01 → const List<List>

strokeRoundedSortByUp02 → const List<List>

strokeRoundedSortDescending → const List<List>

strokeRoundedSorting01 → const List<List>

strokeRoundedSorting02 → const List<List>

strokeRoundedSorting03 → const List<List>

strokeRoundedSorting04 → const List<List>

strokeRoundedSorting05 → const List<List>

strokeRoundedSorting19 → const List<List>

strokeRoundedSorting91 → const List<List>

strokeRoundedSortingAZ01 → const List<List>

strokeRoundedSortingAZ02 → const List<List>

strokeRoundedSortingDown → const List<List>

strokeRoundedSortingUp → const List<List>

strokeRoundedSortingZA01 → const List<List>

strokeRoundedSoundcloud → const List<List>

strokeRoundedSourceCode → const List<List>

strokeRoundedSourceCodeCircle → const List<List>

strokeRoundedSourceCodeSquare → const List<List>

strokeRoundedSpaceship → const List<List>

strokeRoundedSpades → const List<List>

strokeRoundedSpaghetti → const List<List>

strokeRoundedSpam → const List<List>

strokeRoundedSparkles → const List<List>

strokeRoundedSpartanHelmet → const List<List>

strokeRoundedSpatula → const List<List>

strokeRoundedSpeaker → const List<List>

strokeRoundedSpeaker01 → const List<List>

strokeRoundedSpeech → const List<List>

strokeRoundedSpeechToText → const List<List>

strokeRoundedSpeedTrain01 → const List<List>

strokeRoundedSpeedTrain02 → const List<List>

strokeRoundedSperm → const List<List>

strokeRoundedSphere → const List<List>

strokeRoundedSpirals → const List<List>

strokeRoundedSplinePointer → const List<List>

strokeRoundedSplit → const List<List>

strokeRoundedSpool → const List<List>

strokeRoundedSpoon → const List<List>

strokeRoundedSpoonAndFork → const List<List>

strokeRoundedSpoonAndKnife → const List<List>

strokeRoundedSpotify → const List<List>

strokeRoundedSpotlight → const List<List>

strokeRoundedSprayCan → const List<List>

strokeRoundedSql → const List<List>

strokeRoundedSquare → const List<List>

strokeRoundedSquare01 → const List<List>

strokeRoundedSquareArrowDataTransferDiagonal → const List<List>

strokeRoundedSquareArrowDataTransferHorizontal → const List<List>

strokeRoundedSquareArrowDataTransferVertical → const List<List>

strokeRoundedSquareArrowDiagonal01 → const List<List>

strokeRoundedSquareArrowDiagonal02 → const List<List>

strokeRoundedSquareArrowDown01 → const List<List>

strokeRoundedSquareArrowDown02 → const List<List>

strokeRoundedSquareArrowDown03 → const List<List>

strokeRoundedSquareArrowDownDouble → const List<List>

strokeRoundedSquareArrowDownLeft → const List<List>

strokeRoundedSquareArrowDownRight → const List<List>

strokeRoundedSquareArrowExpand01 → const List<List>

strokeRoundedSquareArrowExpand02 → const List<List>

strokeRoundedSquareArrowHorizontal → const List<List>

strokeRoundedSquareArrowLeft01 → const List<List>

strokeRoundedSquareArrowLeft02 → const List<List>

strokeRoundedSquareArrowLeft03 → const List<List>

strokeRoundedSquareArrowLeftDouble → const List<List>

strokeRoundedSquareArrowLeftRight → const List<List>

strokeRoundedSquareArrowMoveDownLeft → const List<List>

strokeRoundedSquareArrowMoveDownRight → const List<List>

strokeRoundedSquareArrowMoveLeftDown → const List<List>

strokeRoundedSquareArrowMoveLeftUp → const List<List>

strokeRoundedSquareArrowMoveRightDown → const List<List>

strokeRoundedSquareArrowMoveRightUp → const List<List>

strokeRoundedSquareArrowReload01 → const List<List>

strokeRoundedSquareArrowReload02 → const List<List>

strokeRoundedSquareArrowRight01 → const List<List>

strokeRoundedSquareArrowRight02 → const List<List>

strokeRoundedSquareArrowRight03 → const List<List>

strokeRoundedSquareArrowRightDouble → const List<List>

strokeRoundedSquareArrowShrink01 → const List<List>

strokeRoundedSquareArrowShrink02 → const List<List>

strokeRoundedSquareArrowUp01 → const List<List>

strokeRoundedSquareArrowUp02 → const List<List>

strokeRoundedSquareArrowUp03 → const List<List>

strokeRoundedSquareArrowUpDouble → const List<List>

strokeRoundedSquareArrowUpDown → const List<List>

strokeRoundedSquareArrowUpLeft → const List<List>

strokeRoundedSquareArrowUpRight → const List<List>

strokeRoundedSquareArrowUpRight02 → const List<List>

strokeRoundedSquareArrowVertical → const List<List>

strokeRoundedSquareAsterisk → const List<List>

strokeRoundedSquareBottomDashedScissors → const List<List>

strokeRoundedSquareChartGantt → const List<List>

strokeRoundedSquareCircle → const List<List>

strokeRoundedSquareDashedKanban → const List<List>

strokeRoundedSquareDashedTopSolid → const List<List>

strokeRoundedSquareF → const List<List>

strokeRoundedSquareLock01 → const List<List>

strokeRoundedSquareLock02 → const List<List>

strokeRoundedSquareLockAdd01 → const List<List>

strokeRoundedSquareLockAdd02 → const List<List>

strokeRoundedSquareLockCheck01 → const List<List>

strokeRoundedSquareLockCheck02 → const List<List>

strokeRoundedSquareLockMinus01 → const List<List>

strokeRoundedSquareLockMinus02 → const List<List>

strokeRoundedSquareLockPassword → const List<List>

strokeRoundedSquareLockRemove01 → const List<List>

strokeRoundedSquareLockRemove02 → const List<List>

strokeRoundedSquareM → const List<List>

strokeRoundedSquareMousePointer → const List<List>

strokeRoundedSquareParkingOff → const List<List>

strokeRoundedSquarePower → const List<List>

strokeRoundedSquareRootSquare → const List<List>

strokeRoundedSquareRoundCorner → const List<List>

strokeRoundedSquaresExclude → const List<List>

strokeRoundedSquareSingleFire → const List<List>

strokeRoundedSquareSquare → const List<List>

strokeRoundedSquareStack → const List<List>

strokeRoundedSquareUnlock01 → const List<List>

strokeRoundedSquareUnlock02 → const List<List>

strokeRoundedStackStar → const List<List>

strokeRoundedStairs01 → const List<List>

strokeRoundedStairs02 → const List<List>

strokeRoundedStairs03 → const List<List>

strokeRoundedStairs04 → const List<List>

strokeRoundedStake → const List<List>

strokeRoundedStamp → const List<List>

strokeRoundedStamp01 → const List<List>

strokeRoundedStamp02 → const List<List>

strokeRoundedStar → const List<List>

strokeRoundedStarAward01 → const List<List>

strokeRoundedStarAward02 → const List<List>

strokeRoundedStarCircle → const List<List>

strokeRoundedStarFace → const List<List>

strokeRoundedStarHalf → const List<List>

strokeRoundedStarOff → const List<List>

strokeRoundedStars → const List<List>

strokeRoundedStarSquare → const List<List>

strokeRoundedStartUp01 → const List<List>

strokeRoundedStartUp02 → const List<List>

strokeRoundedStationery → const List<List>

strokeRoundedStatus → const List<List>

strokeRoundedSteak → const List<List>

strokeRoundedSteering → const List<List>

strokeRoundedStepInto → const List<List>

strokeRoundedStepOut → const List<List>

strokeRoundedStepOver → const List<List>

strokeRoundedStethoscope → const List<List>

strokeRoundedStethoscope02 → const List<List>

strokeRoundedSticker → const List<List>

strokeRoundedStickyNote01 → const List<List>

strokeRoundedStickyNote02 → const List<List>

strokeRoundedStickyNote03 → const List<List>

strokeRoundedStop → const List<List>

strokeRoundedStopCircle → const List<List>

strokeRoundedStopLossOrder → const List<List>

strokeRoundedStopWatch → const List<List>

strokeRoundedStore01 → const List<List>

strokeRoundedStore02 → const List<List>

strokeRoundedStore03 → const List<List>

strokeRoundedStore04 → const List<List>

strokeRoundedStoreAdd01 → const List<List>

strokeRoundedStoreAdd02 → const List<List>

strokeRoundedStoreLocation01 → const List<List>

strokeRoundedStoreLocation02 → const List<List>

strokeRoundedStoreManagement01 → const List<List>

strokeRoundedStoreManagement02 → const List<List>

strokeRoundedStoreRemove01 → const List<List>

strokeRoundedStoreRemove02 → const List<List>

strokeRoundedStoreVerified01 → const List<List>

strokeRoundedStoreVerified02 → const List<List>

strokeRoundedStraightEdge → const List<List>

strokeRoundedStrategy → const List<List>

strokeRoundedStreeringWheel → const List<List>

strokeRoundedStreetFood → const List<List>

strokeRoundedStripe → const List<List>

strokeRoundedStrokeBottom → const List<List>

strokeRoundedStrokeCenter → const List<List>

strokeRoundedStrokeInside → const List<List>

strokeRoundedStrokeLeft → const List<List>

strokeRoundedStrokeOutside → const List<List>

strokeRoundedStrokeRight → const List<List>

strokeRoundedStrokeTop → const List<List>

strokeRoundedStructure01 → const List<List>

strokeRoundedStructure02 → const List<List>

strokeRoundedStructure03 → const List<List>

strokeRoundedStructure04 → const List<List>

strokeRoundedStructure05 → const List<List>

strokeRoundedStructureAdd → const List<List>

strokeRoundedStructureCheck → const List<List>

strokeRoundedStructureFail → const List<List>

strokeRoundedStructureFolder → const List<List>

strokeRoundedStructureFolderCircle → const List<List>

strokeRoundedStudent → const List<List>

strokeRoundedStudentCard → const List<List>

strokeRoundedStudents → const List<List>

strokeRoundedStudyDesk → const List<List>

strokeRoundedStudyLamp → const List<List>

strokeRoundedStumbleupon → const List<List>

strokeRoundedSubmarine → const List<List>

strokeRoundedSubmerge → const List<List>

strokeRoundedSubnodeAdd → const List<List>

strokeRoundedSubnodeDelete → const List<List>

strokeRoundedSubpoena → const List<List>

strokeRoundedSubtitle → const List<List>

strokeRoundedSuit01 → const List<List>

strokeRoundedSuit02 → const List<List>

strokeRoundedSujood → const List<List>

strokeRoundedSummation01 → const List<List>

strokeRoundedSummation02 → const List<List>

strokeRoundedSummationCircle → const List<List>

strokeRoundedSummationSquare → const List<List>

strokeRoundedSun01 → const List<List>

strokeRoundedSun02 → const List<List>

strokeRoundedSun03 → const List<List>

strokeRoundedSunCloud01 → const List<List>

strokeRoundedSunCloud02 → const List<List>

strokeRoundedSunCloudAngledRain01 → const List<List>

strokeRoundedSunCloudAngledRain02 → const List<List>

strokeRoundedSunCloudAngledRainZap01 → const List<List>

strokeRoundedSunCloudAngledRainZap02 → const List<List>

strokeRoundedSunCloudAngledZap01 → const List<List>

strokeRoundedSunCloudAngledZap02 → const List<List>

strokeRoundedSunCloudBigRain01 → const List<List>

strokeRoundedSunCloudBigRain02 → const List<List>

strokeRoundedSunCloudFastWind01 → const List<List>

strokeRoundedSunCloudFastWind02 → const List<List>

strokeRoundedSunCloudHailstone01 → const List<List>

strokeRoundedSunCloudHailstone02 → const List<List>

strokeRoundedSunCloudLittleRain01 → const List<List>

strokeRoundedSunCloudLittleRain02 → const List<List>

strokeRoundedSunCloudLittleSnow01 → const List<List>

strokeRoundedSunCloudLittleSnow02 → const List<List>

strokeRoundedSunCloudMidRain01 → const List<List>

strokeRoundedSunCloudMidRain02 → const List<List>

strokeRoundedSunCloudMidSnow01 → const List<List>

strokeRoundedSunCloudMidSnow02 → const List<List>

strokeRoundedSunCloudSlowWind01 → const List<List>

strokeRoundedSunCloudSlowWind02 → const List<List>

strokeRoundedSunCloudSnow01 → const List<List>

strokeRoundedSunCloudSnow02 → const List<List>

strokeRoundedSunglasses → const List<List>

strokeRoundedSunrise → const List<List>

strokeRoundedSunset → const List<List>

strokeRoundedSuperMario → const List<List>

strokeRoundedSuperMarioToad → const List<List>

strokeRoundedSurfboard → const List<List>

strokeRoundedSurprise → const List<List>

strokeRoundedSushi01 → const List<List>

strokeRoundedSushi02 → const List<List>

strokeRoundedSushi03 → const List<List>

strokeRoundedSuspicious → const List<List>

strokeRoundedSustainableEnergy → const List<List>

strokeRoundedSvg01 → const List<List>

strokeRoundedSvg02 → const List<List>

strokeRoundedSwarm → const List<List>

strokeRoundedSwatch → const List<List>

strokeRoundedSwimming → const List<List>

strokeRoundedSwimmingCap → const List<List>

strokeRoundedSwipeDown01 → const List<List>

strokeRoundedSwipeDown02 → const List<List>

strokeRoundedSwipeDown03 → const List<List>

strokeRoundedSwipeDown04 → const List<List>

strokeRoundedSwipeDown05 → const List<List>

strokeRoundedSwipeDown06 → const List<List>

strokeRoundedSwipeDown07 → const List<List>

strokeRoundedSwipeDown08 → const List<List>

strokeRoundedSwipeLeft01 → const List<List>

strokeRoundedSwipeLeft02 → const List<List>

strokeRoundedSwipeLeft03 → const List<List>

strokeRoundedSwipeLeft04 → const List<List>

strokeRoundedSwipeLeft05 → const List<List>

strokeRoundedSwipeLeft06 → const List<List>

strokeRoundedSwipeLeft07 → const List<List>

strokeRoundedSwipeLeft08 → const List<List>

strokeRoundedSwipeLeft09 → const List<List>

strokeRoundedSwipeRight01 → const List<List>

strokeRoundedSwipeRight02 → const List<List>

strokeRoundedSwipeRight03 → const List<List>

strokeRoundedSwipeRight04 → const List<List>

strokeRoundedSwipeRight05 → const List<List>

strokeRoundedSwipeRight06 → const List<List>

strokeRoundedSwipeRight07 → const List<List>

strokeRoundedSwipeRight08 → const List<List>

strokeRoundedSwipeRight09 → const List<List>

strokeRoundedSwipeUp01 → const List<List>

strokeRoundedSwipeUp02 → const List<List>

strokeRoundedSwipeUp03 → const List<List>

strokeRoundedSwipeUp04 → const List<List>

strokeRoundedSwipeUp05 → const List<List>

strokeRoundedSwipeUp06 → const List<List>

strokeRoundedSwipeUp07 → const List<List>

strokeRoundedSwipeUp08 → const List<List>

strokeRoundedSwissFranc → const List<List>

strokeRoundedSwitchCamera → const List<List>

strokeRoundedSword01 → const List<List>

strokeRoundedSword02 → const List<List>

strokeRoundedSword03 → const List<List>

strokeRoundedSystemUpdate01 → const List<List>

strokeRoundedSystemUpdate02 → const List<List>

strokeRoundedTable → const List<List>

strokeRoundedTable01 → const List<List>

strokeRoundedTable02 → const List<List>

strokeRoundedTable03 → const List<List>

strokeRoundedTableColumnsSplit → const List<List>

strokeRoundedTableLamp01 → const List<List>

strokeRoundedTableLamp02 → const List<List>

strokeRoundedTableRound → const List<List>

strokeRoundedTableRowsSplit → const List<List>

strokeRoundedTablet01 → const List<List>

strokeRoundedTablet02 → const List<List>

strokeRoundedTabletConnectedBluetooth → const List<List>

strokeRoundedTabletConnectedUsb → const List<List>

strokeRoundedTabletConnectedWifi → const List<List>

strokeRoundedTableTennisBat → const List<List>

strokeRoundedTabletPen → const List<List>

strokeRoundedTablets → const List<List>

strokeRoundedTaco01 → const List<List>

strokeRoundedTaco02 → const List<List>

strokeRoundedTag01 → const List<List>

strokeRoundedTag02 → const List<List>

strokeRoundedTags → const List<List>

strokeRoundedTailwindcss → const List<List>

strokeRoundedTajMahal → const List<List>

strokeRoundedTally1 → const List<List>

strokeRoundedTally2 → const List<List>

strokeRoundedTally3 → const List<List>

strokeRoundedTally4 → const List<List>

strokeRoundedTally5 → const List<List>

strokeRoundedTan → const List<List>

strokeRoundedTangent → const List<List>

strokeRoundedTankerTruck → const List<List>

strokeRoundedTankTop → const List<List>

strokeRoundedTap01 → const List<List>

strokeRoundedTap02 → const List<List>

strokeRoundedTap03 → const List<List>

strokeRoundedTap04 → const List<List>

strokeRoundedTap05 → const List<List>

strokeRoundedTap06 → const List<List>

strokeRoundedTap07 → const List<List>

strokeRoundedTap08 → const List<List>

strokeRoundedTapeMeasure → const List<List>

strokeRoundedTarget01 → const List<List>

strokeRoundedTarget02 → const List<List>

strokeRoundedTarget03 → const List<List>

strokeRoundedTargetDollar → const List<List>

strokeRoundedTasbih → const List<List>

strokeRoundedTask01 → const List<List>

strokeRoundedTask02 → const List<List>

strokeRoundedTaskAdd01 → const List<List>

strokeRoundedTaskAdd02 → const List<List>

strokeRoundedTaskDaily01 → const List<List>

strokeRoundedTaskDaily02 → const List<List>

strokeRoundedTaskDone01 → const List<List>

strokeRoundedTaskDone02 → const List<List>

strokeRoundedTaskEdit01 → const List<List>

strokeRoundedTaskEdit02 → const List<List>

strokeRoundedTaskRemove01 → const List<List>

strokeRoundedTaskRemove02 → const List<List>

strokeRoundedTaxes → const List<List>

strokeRoundedTaxi → const List<List>

strokeRoundedTaxi02 → const List<List>

strokeRoundedTea → const List<List>

strokeRoundedTeacher → const List<List>

strokeRoundedTeaching → const List<List>

strokeRoundedTeamviewer → const List<List>

strokeRoundedTeamWork → const List<List>

strokeRoundedTeaPod → const List<List>

strokeRoundedTelegram → const List<List>

strokeRoundedTelephone → const List<List>

strokeRoundedTelescope01 → const List<List>

strokeRoundedTelescope02 → const List<List>

strokeRoundedTelevisionTable → const List<List>

strokeRoundedTemperature → const List<List>

strokeRoundedTennisBall → const List<List>

strokeRoundedTennisRacket → const List<List>

strokeRoundedTent → const List<List>

strokeRoundedTentTree → const List<List>

strokeRoundedTerminal → const List<List>

strokeRoundedTerrace → const List<List>

strokeRoundedTestTube → const List<List>

strokeRoundedTestTube01 → const List<List>

strokeRoundedTestTube02 → const List<List>

strokeRoundedTestTube03 → const List<List>

strokeRoundedTestTubeDiagonal → const List<List>

strokeRoundedTestTubes → const List<List>

strokeRoundedTetris → const List<List>

strokeRoundedText → const List<List>

strokeRoundedTextAlignCenter → const List<List>

strokeRoundedTextAlignJustifyCenter → const List<List>

strokeRoundedTextAlignJustifyLeft → const List<List>

strokeRoundedTextAlignJustifyRight → const List<List>

strokeRoundedTextAlignLeft → const List<List>

strokeRoundedTextAlignLeft01 → const List<List>

strokeRoundedTextAlignRight → const List<List>

strokeRoundedTextAlignRight01 → const List<List>

strokeRoundedTextAllCaps → const List<List>

strokeRoundedTextBold → const List<List>

strokeRoundedTextCenterlineCenterTop → const List<List>

strokeRoundedTextCenterlineLeft → const List<List>

strokeRoundedTextCenterlineMiddle → const List<List>

strokeRoundedTextCenterlineRight → const List<List>

strokeRoundedTextCheck → const List<List>

strokeRoundedTextCircle → const List<List>

strokeRoundedTextClear → const List<List>

strokeRoundedTextColor → const List<List>

strokeRoundedTextCreation → const List<List>

strokeRoundedTextFirstlineLeft → const List<List>

strokeRoundedTextFirstlineRight → const List<List>

strokeRoundedTextFont → const List<List>

strokeRoundedTextFootnote → const List<List>

strokeRoundedTextIndent → const List<List>

strokeRoundedTextIndent01 → const List<List>

strokeRoundedTextIndentLess → const List<List>

strokeRoundedTextIndentMore → const List<List>

strokeRoundedTextItalic → const List<List>

strokeRoundedTextItalicSlash → const List<List>

strokeRoundedTextKerning → const List<List>

strokeRoundedTextNumberSign → const List<List>

strokeRoundedTextSelect → const List<List>

strokeRoundedTextSelection → const List<List>

strokeRoundedTextSmallcaps → const List<List>

strokeRoundedTextSquare → const List<List>

strokeRoundedTextStrikethrough → const List<List>

strokeRoundedTextSubscript → const List<List>

strokeRoundedTextSuperscript → const List<List>

strokeRoundedTextTracking → const List<List>

strokeRoundedTextUnderline → const List<List>

strokeRoundedTextVariableFront → const List<List>

strokeRoundedTextVerticalAlignment → const List<List>

strokeRoundedTextWrap → const List<List>

strokeRoundedTheater → const List<List>

strokeRoundedTheProphetsMosque → const List<List>

strokeRoundedThermometer → const List<List>

strokeRoundedThermometerCold → const List<List>

strokeRoundedThermometerWarm → const List<List>

strokeRoundedThread → const List<List>

strokeRoundedThreads → const List<List>

strokeRoundedThreadsEllipse → const List<List>

strokeRoundedThreadsRectangle → const List<List>

strokeRoundedThreeCircle → const List<List>

strokeRoundedThreeFinger01 → const List<List>

strokeRoundedThreeFinger02 → const List<List>

strokeRoundedThreeFinger03 → const List<List>

strokeRoundedThreeFinger04 → const List<List>

strokeRoundedThreeFinger05 → const List<List>

strokeRoundedThreeSquare → const List<List>

strokeRoundedThumbsDown → const List<List>

strokeRoundedThumbsDownEllipse → const List<List>

strokeRoundedThumbsDownRectangle → const List<List>

strokeRoundedThumbsUp → const List<List>

strokeRoundedThumbsUpDown → const List<List>

strokeRoundedThumbsUpEllipse → const List<List>

strokeRoundedThumbsUpRectangle → const List<List>

strokeRoundedTick01 → const List<List>

strokeRoundedTick02 → const List<List>

strokeRoundedTick03 → const List<List>

strokeRoundedTick04 → const List<List>

strokeRoundedTickDouble01 → const List<List>

strokeRoundedTickDouble02 → const List<List>

strokeRoundedTickDouble03 → const List<List>

strokeRoundedTickDouble04 → const List<List>

strokeRoundedTicket01 → const List<List>

strokeRoundedTicket02 → const List<List>

strokeRoundedTicket03 → const List<List>

strokeRoundedTicketStar → const List<List>

strokeRoundedTicTacToe → const List<List>

strokeRoundedTie → const List<List>

strokeRoundedTiff01 → const List<List>

strokeRoundedTiff02 → const List<List>

strokeRoundedTiktok → const List<List>

strokeRoundedTiltify → const List<List>

strokeRoundedTime01 → const List<List>

strokeRoundedTime02 → const List<List>

strokeRoundedTime03 → const List<List>

strokeRoundedTime04 → const List<List>

strokeRoundedTimeHalfPass → const List<List>

strokeRoundedTimeline → const List<List>

strokeRoundedTimelineEvent → const List<List>

strokeRoundedTimelineList → const List<List>

strokeRoundedTimeManagement → const List<List>

strokeRoundedTimeManagementCircle → const List<List>

strokeRoundedTimeQuarter → const List<List>

strokeRoundedTimeQuarter02 → const List<List>

strokeRoundedTimeQuarterPass → const List<List>

strokeRoundedTimer01 → const List<List>

strokeRoundedTimer02 → const List<List>

strokeRoundedTimeSchedule → const List<List>

strokeRoundedTimeSetting01 → const List<List>

strokeRoundedTimeSetting02 → const List<List>

strokeRoundedTimeSetting03 → const List<List>

strokeRoundedTimeZone → const List<List>

strokeRoundedTinder → const List<List>

strokeRoundedTinderSquare → const List<List>

strokeRoundedTips → const List<List>

strokeRoundedTire → const List<List>

strokeRoundedTired01 → const List<List>

strokeRoundedTired02 → const List<List>

strokeRoundedTissuePaper → const List<List>

strokeRoundedToggleOff → const List<List>

strokeRoundedToggleOn → const List<List>

strokeRoundedToilet01 → const List<List>

strokeRoundedToilet02 → const List<List>

strokeRoundedTokenCircle → const List<List>

strokeRoundedTokenSquare → const List<List>

strokeRoundedTongue → const List<List>

strokeRoundedTongue01 → const List<List>

strokeRoundedTongueWinkLeft → const List<List>

strokeRoundedTongueWinkRight → const List<List>

strokeRoundedToolbox → const List<List>

strokeRoundedToolCase → const List<List>

strokeRoundedTools → const List<List>

strokeRoundedTornado01 → const List<List>

strokeRoundedTornado02 → const List<List>

strokeRoundedTorriGate → const List<List>

strokeRoundedTorus → const List<List>

strokeRoundedTouch01 → const List<List>

strokeRoundedTouch02 → const List<List>

strokeRoundedTouch03 → const List<List>

strokeRoundedTouch04 → const List<List>

strokeRoundedTouch05 → const List<List>

strokeRoundedTouch06 → const List<List>

strokeRoundedTouch07 → const List<List>

strokeRoundedTouch08 → const List<List>

strokeRoundedTouch09 → const List<List>

strokeRoundedTouch10 → const List<List>

strokeRoundedTouchInteraction01 → const List<List>

strokeRoundedTouchInteraction02 → const List<List>

strokeRoundedTouchInteraction03 → const List<List>

strokeRoundedTouchInteraction04 → const List<List>

strokeRoundedTouchLocked01 → const List<List>

strokeRoundedTouchLocked02 → const List<List>

strokeRoundedTouchLocked03 → const List<List>

strokeRoundedTouchLocked04 → const List<List>

strokeRoundedTouchpad01 → const List<List>

strokeRoundedTouchpad02 → const List<List>

strokeRoundedTouchpad03 → const List<List>

strokeRoundedTouchpad04 → const List<List>

strokeRoundedTouchpadOff → const List<List>

strokeRoundedTowels → const List<List>

strokeRoundedTowTruck → const List<List>

strokeRoundedToyBrick → const List<List>

strokeRoundedToyTrain → const List<List>

strokeRoundedTractor → const List<List>

strokeRoundedTradeDown → const List<List>

strokeRoundedTradeMark → const List<List>

strokeRoundedTrademark → const List<List>

strokeRoundedTradeUp → const List<List>

strokeRoundedTrafficIncident → const List<List>

strokeRoundedTrafficJam01 → const List<List>

strokeRoundedTrafficJam02 → const List<List>

strokeRoundedTrafficLight → const List<List>

strokeRoundedTrain01 → const List<List>

strokeRoundedTrain02 → const List<List>

strokeRoundedTrainTrack → const List<List>

strokeRoundedTram → const List<List>

strokeRoundedTrampoline → const List<List>

strokeRoundedTransaction → const List<List>

strokeRoundedTransactionHistory → const List<List>

strokeRoundedTransitionBottom → const List<List>

strokeRoundedTransitionLeft → const List<List>

strokeRoundedTransitionRight → const List<List>

strokeRoundedTransitionTop → const List<List>

strokeRoundedTranslate → const List<List>

strokeRoundedTranslation → const List<List>

strokeRoundedTransmission → const List<List>

strokeRoundedTransparency → const List<List>

strokeRoundedTrapezoidLineHorizontal → const List<List>

strokeRoundedTrapezoidLineVertical → const List<List>

strokeRoundedTravelBag → const List<List>

strokeRoundedTreadmill01 → const List<List>

strokeRoundedTreadmill02 → const List<List>

strokeRoundedTreatment → const List<List>

strokeRoundedTree01 → const List<List>

strokeRoundedTree02 → const List<List>

strokeRoundedTree03 → const List<List>

strokeRoundedTree04 → const List<List>

strokeRoundedTree05 → const List<List>

strokeRoundedTree06 → const List<List>

strokeRoundedTree07 → const List<List>

strokeRoundedTreePalm → const List<List>

strokeRoundedTrees → const List<List>

strokeRoundedTrello → const List<List>

strokeRoundedTrendingUpDown → const List<List>

strokeRoundedTriangle → const List<List>

strokeRoundedTriangle01 → const List<List>

strokeRoundedTriangle02 → const List<List>

strokeRoundedTriangle03 → const List<List>

strokeRoundedTriangleDash → const List<List>

strokeRoundedTriangleRight → const List<List>

strokeRoundedTrolley01 → const List<List>

strokeRoundedTrolley02 → const List<List>

strokeRoundedTropicalStorm → const List<List>

strokeRoundedTropicalStormTracks → const List<List>

strokeRoundedTropicalStormTracks01 → const List<List>

strokeRoundedTropicalStormTracks02 → const List<List>

strokeRoundedTruck → const List<List>

strokeRoundedTruckDelivery → const List<List>

strokeRoundedTruckMonster → const List<List>

strokeRoundedTruckReturn → const List<List>

strokeRoundedTrulli → const List<List>

strokeRoundedTShirt → const List<List>

strokeRoundedTsunami → const List<List>

strokeRoundedTulip → const List<List>

strokeRoundedTumblr → const List<List>

strokeRoundedTurkishLira → const List<List>

strokeRoundedTurtleNeck → const List<List>

strokeRoundedTv01 → const List<List>

strokeRoundedTv02 → const List<List>

strokeRoundedTvFix → const List<List>

strokeRoundedTvIssue → const List<List>

strokeRoundedTvSmart → const List<List>

strokeRoundedTwinTower → const List<List>

strokeRoundedTwitch → const List<List>

strokeRoundedTwitter → const List<List>

strokeRoundedTwitterSquare → const List<List>

strokeRoundedTwoCircle → const List<List>

strokeRoundedTwoFactorAccess → const List<List>

strokeRoundedTwoFinger01 → const List<List>

strokeRoundedTwoFinger02 → const List<List>

strokeRoundedTwoFinger03 → const List<List>

strokeRoundedTwoFinger04 → const List<List>

strokeRoundedTwoFinger05 → const List<List>

strokeRoundedTwoSquare → const List<List>

strokeRoundedTxt01 → const List<List>

strokeRoundedTxt02 → const List<List>

strokeRoundedTypeCursor → const List<List>

strokeRoundedTypescript01 → const List<List>

strokeRoundedTypescript02 → const List<List>

strokeRoundedTypescript03 → const List<List>

strokeRoundedUber → const List<List>

strokeRoundedUfo → const List<List>

strokeRoundedUfo01 → const List<List>

strokeRoundedUmbrella → const List<List>

strokeRoundedUmbrellaDollar → const List<List>

strokeRoundedUmbrellaOff → const List<List>

strokeRoundedUnamused → const List<List>

strokeRoundedUnarchive03 → const List<List>

strokeRoundedUnavailable → const List<List>

strokeRoundedUnderpants01 → const List<List>

strokeRoundedUnderpants02 → const List<List>

strokeRoundedUnderpants03 → const List<List>

strokeRoundedUndo → const List<List>

strokeRoundedUndo02 → const List<List>

strokeRoundedUndo03 → const List<List>

strokeRoundedUnfoldLess → const List<List>

strokeRoundedUnfoldMore → const List<List>

strokeRoundedUnfoldMoreDown → const List<List>

strokeRoundedUnfoldMoreUp → const List<List>

strokeRoundedUngroup → const List<List>

strokeRoundedUngroupItems → const List<List>

strokeRoundedUngroupLayers → const List<List>

strokeRoundedUnhappy → const List<List>

strokeRoundedUniversalAccess → const List<List>

strokeRoundedUniversalAccessCircle → const List<List>

strokeRoundedUniversity → const List<List>

strokeRoundedUnlink01 → const List<List>

strokeRoundedUnlink02 → const List<List>

strokeRoundedUnlink03 → const List<List>

strokeRoundedUnlink04 → const List<List>

strokeRoundedUnlink05 → const List<List>

strokeRoundedUnlink06 → const List<List>

strokeRoundedUnsplash → const List<List>

strokeRoundedUpload01 → const List<List>

strokeRoundedUpload02 → const List<List>

strokeRoundedUpload03 → const List<List>

strokeRoundedUpload04 → const List<List>

strokeRoundedUpload05 → const List<List>

strokeRoundedUpload06 → const List<List>

strokeRoundedUploadCircle01 → const List<List>

strokeRoundedUploadCircle02 → const List<List>

strokeRoundedUploadSquare01 → const List<List>

strokeRoundedUploadSquare02 → const List<List>

strokeRoundedUpwork → const List<List>

strokeRoundedUsb → const List<List>

strokeRoundedUsbBugs → const List<List>

strokeRoundedUsbConnected01 → const List<List>

strokeRoundedUsbConnected02 → const List<List>

strokeRoundedUsbConnected03 → const List<List>

strokeRoundedUsbError → const List<List>

strokeRoundedUsbMemory01 → const List<List>

strokeRoundedUsbMemory02 → const List<List>

strokeRoundedUsbNotConnected01 → const List<List>

strokeRoundedUsbNotConnected02 → const List<List>

strokeRoundedUsdt → const List<List>

strokeRoundedUser → const List<List>

strokeRoundedUser02 → const List<List>

strokeRoundedUser03 → const List<List>

strokeRoundedUserAccount → const List<List>

strokeRoundedUserAdd01 → const List<List>

strokeRoundedUserAdd02 → const List<List>

strokeRoundedUserAi → const List<List>

strokeRoundedUserArrowLeftRight → const List<List>

strokeRoundedUserBlock01 → const List<List>

strokeRoundedUserBlock02 → const List<List>

strokeRoundedUserCheck01 → const List<List>

strokeRoundedUserCheck02 → const List<List>

strokeRoundedUserCircle → const List<List>

strokeRoundedUserCircle02 → const List<List>

strokeRoundedUserDollar → const List<List>

strokeRoundedUserEdit01 → const List<List>

strokeRoundedUserFullView → const List<List>

strokeRoundedUserGroup → const List<List>

strokeRoundedUserGroup02 → const List<List>

strokeRoundedUserGroup03 → const List<List>

strokeRoundedUserIdVerification → const List<List>

strokeRoundedUserList → const List<List>

strokeRoundedUserLock01 → const List<List>

strokeRoundedUserLock02 → const List<List>

strokeRoundedUserLove01 → const List<List>

strokeRoundedUserLove02 → const List<List>

strokeRoundedUserMinus01 → const List<List>

strokeRoundedUserMinus02 → const List<List>

strokeRoundedUserMultiple → const List<List>

strokeRoundedUserMultiple02 → const List<List>

strokeRoundedUserMultiple03 → const List<List>

strokeRoundedUserQuestion01 → const List<List>

strokeRoundedUserQuestion02 → const List<List>

strokeRoundedUserRemove01 → const List<List>

strokeRoundedUserRemove02 → const List<List>

strokeRoundedUserRoadside → const List<List>

strokeRoundedUserSearch01 → const List<List>

strokeRoundedUserSearch02 → const List<List>

strokeRoundedUserSettings01 → const List<List>

strokeRoundedUserSettings02 → const List<List>

strokeRoundedUserSharing → const List<List>

strokeRoundedUserShield01 → const List<List>

strokeRoundedUserShield02 → const List<List>

strokeRoundedUserSquare → const List<List>

strokeRoundedUserStar01 → const List<List>

strokeRoundedUserStar02 → const List<List>

strokeRoundedUserStatus → const List<List>

strokeRoundedUserStory → const List<List>

strokeRoundedUserSwitch → const List<List>

strokeRoundedUserTime01 → const List<List>

strokeRoundedUserTime02 → const List<List>

strokeRoundedUserTime03 → const List<List>

strokeRoundedUserUnlock01 → const List<List>

strokeRoundedUserUnlock02 → const List<List>

strokeRoundedUserWarning01 → const List<List>

strokeRoundedUserWarning02 → const List<List>

strokeRoundedUserWarning03 → const List<List>

strokeRoundedUtilityPole → const List<List>

strokeRoundedUv01 → const List<List>

strokeRoundedUv02 → const List<List>

strokeRoundedUv03 → const List<List>

strokeRoundedVaccine → const List<List>

strokeRoundedVacuumCleaner → const List<List>

strokeRoundedValidation → const List<List>

strokeRoundedValidationApproval → const List<List>

strokeRoundedVan → const List<List>

strokeRoundedVariable → const List<List>

strokeRoundedVectorSquare → const List<List>

strokeRoundedVegetarianFood → const List<List>

strokeRoundedVenetianMask → const List<List>

strokeRoundedVersus → const List<List>

strokeRoundedVerticalResize → const List<List>

strokeRoundedVerticalScrollPoint → const List<List>

strokeRoundedVest → const List<List>

strokeRoundedViber → const List<List>

strokeRoundedVibrate → const List<List>

strokeRoundedVictoryFinger01 → const List<List>

strokeRoundedVictoryFinger02 → const List<List>

strokeRoundedVictoryFinger03 → const List<List>

strokeRoundedVideo01 → const List<List>

strokeRoundedVideo02 → const List<List>

strokeRoundedVideoAi → const List<List>

strokeRoundedVideoCameraAi → const List<List>

strokeRoundedVideoConsole → const List<List>

strokeRoundedVideoOff → const List<List>

strokeRoundedVideoReplay → const List<List>

strokeRoundedVideotape → const List<List>

strokeRoundedView → const List<List>

strokeRoundedViewAgenda → const List<List>

strokeRoundedViewOff → const List<List>

strokeRoundedViewOffSlash → const List<List>

strokeRoundedViewSidebarLeft → const List<List>

strokeRoundedViewSidebarRight → const List<List>

strokeRoundedVilla01 → const List<List>

strokeRoundedVilla02 → const List<List>

strokeRoundedVimeo → const List<List>

strokeRoundedVine → const List<List>

strokeRoundedVineSquare → const List<List>

strokeRoundedVintageClock → const List<List>

strokeRoundedVirtualRealityVr01 → const List<List>

strokeRoundedVirtualRealityVr02 → const List<List>

strokeRoundedVision → const List<List>

strokeRoundedVisualStudioCode → const List<List>

strokeRoundedVk → const List<List>

strokeRoundedVkSquare → const List<List>

strokeRoundedVoice → const List<List>

strokeRoundedVoiceId → const List<List>

strokeRoundedVolleyball → const List<List>

strokeRoundedVolumeHigh → const List<List>

strokeRoundedVolumeLow → const List<List>

strokeRoundedVolumeMinus → const List<List>

strokeRoundedVolumeMute01 → const List<List>

strokeRoundedVolumeMute02 → const List<List>

strokeRoundedVolumeOff → const List<List>

strokeRoundedVolumeUp → const List<List>

strokeRoundedVomiting → const List<List>

strokeRoundedVoucher → const List<List>

strokeRoundedVr → const List<List>

strokeRoundedVrGlasses → const List<List>

strokeRoundedVynil01 → const List<List>

strokeRoundedVynil02 → const List<List>

strokeRoundedVynil03 → const List<List>

strokeRoundedW3Schools → const List<List>

strokeRoundedWaiter → const List<List>

strokeRoundedWaiters → const List<List>

strokeRoundedWalking → const List<List>

strokeRoundedWallet01 → const List<List>

strokeRoundedWallet02 → const List<List>

strokeRoundedWallet03 → const List<List>

strokeRoundedWallet04 → const List<List>

strokeRoundedWallet05 → const List<List>

strokeRoundedWalletAdd01 → const List<List>

strokeRoundedWalletAdd02 → const List<List>

strokeRoundedWalletCards → const List<List>

strokeRoundedWalletDone01 → const List<List>

strokeRoundedWalletDone02 → const List<List>

strokeRoundedWalletNotFound01 → const List<List>

strokeRoundedWalletNotFound02 → const List<List>

strokeRoundedWalletRemove01 → const List<List>

strokeRoundedWalletRemove02 → const List<List>

strokeRoundedWallLamp → const List<List>

strokeRoundedWalpaper → const List<List>

strokeRoundedWanted → const List<List>

strokeRoundedWardrobe01 → const List<List>

strokeRoundedWardrobe02 → const List<List>

strokeRoundedWardrobe03 → const List<List>

strokeRoundedWardrobe04 → const List<List>

strokeRoundedWarehouse → const List<List>

strokeRoundedWashingMachine → const List<List>

strokeRoundedWashingtonMonument → const List<List>

strokeRoundedWaste → const List<List>

strokeRoundedWasteRestore → const List<List>

strokeRoundedWatch01 → const List<List>

strokeRoundedWatch02 → const List<List>

strokeRoundedWaterEnergy → const List<List>

strokeRoundedWaterfallDown01 → const List<List>

strokeRoundedWaterfallDown03 → const List<List>

strokeRoundedWaterfallUp01 → const List<List>

strokeRoundedWaterfallUp02 → const List<List>

strokeRoundedWatermelon → const List<List>

strokeRoundedWaterPolo → const List<List>

strokeRoundedWaterPump → const List<List>

strokeRoundedWattpad → const List<List>

strokeRoundedWattpadSquare → const List<List>

strokeRoundedWav01 → const List<List>

strokeRoundedWav02 → const List<List>

strokeRoundedWave → const List<List>

strokeRoundedWaveSquare → const List<List>

strokeRoundedWaveTriangle → const List<List>

strokeRoundedWavingHand01 → const List<List>

strokeRoundedWavingHand02 → const List<List>

strokeRoundedWaze → const List<List>

strokeRoundedWebDesign01 → const List<List>

strokeRoundedWebDesign02 → const List<List>

strokeRoundedWebflow → const List<List>

strokeRoundedWebflowEllipse → const List<List>

strokeRoundedWebflowRectangle → const List<List>

strokeRoundedWebhook → const List<List>

strokeRoundedWebhookOff → const List<List>

strokeRoundedWebProgramming → const List<List>

strokeRoundedWebProtection → const List<List>

strokeRoundedWebSecurity → const List<List>

strokeRoundedWebValidation → const List<List>

strokeRoundedWechat → const List<List>

strokeRoundedWedding → const List<List>

strokeRoundedWeight → const List<List>

strokeRoundedWeightScale → const List<List>

strokeRoundedWeightScale01 → const List<List>

strokeRoundedWellness → const List<List>

strokeRoundedWhatsapp → const List<List>

strokeRoundedWhatsappBusiness → const List<List>

strokeRoundedWheat → const List<List>

strokeRoundedWheatOff → const List<List>

strokeRoundedWheelchair → const List<List>

strokeRoundedWhisk → const List<List>

strokeRoundedWhistle → const List<List>

strokeRoundedWhiteboard → const List<List>

strokeRoundedWifi01 → const List<List>

strokeRoundedWifi02 → const List<List>

strokeRoundedWifiCircle → const List<List>

strokeRoundedWifiConnected01 → const List<List>

strokeRoundedWifiConnected02 → const List<List>

strokeRoundedWifiConnected03 → const List<List>

strokeRoundedWifiDisconnected01 → const List<List>

strokeRoundedWifiDisconnected02 → const List<List>

strokeRoundedWifiDisconnected03 → const List<List>

strokeRoundedWifiDisconnected04 → const List<List>

strokeRoundedWifiError01 → const List<List>

strokeRoundedWifiError02 → const List<List>

strokeRoundedWifiFullSignal → const List<List>

strokeRoundedWifiLocation → const List<List>

strokeRoundedWifiLock → const List<List>

strokeRoundedWifiLowSignal → const List<List>

strokeRoundedWifiMediumSignal → const List<List>

strokeRoundedWifiNoSignal → const List<List>

strokeRoundedWifiOff01 → const List<List>

strokeRoundedWifiOff02 → const List<List>

strokeRoundedWifiPen → const List<List>

strokeRoundedWifiSquare → const List<List>

strokeRoundedWifiSync → const List<List>

strokeRoundedWifiUnlock → const List<List>

strokeRoundedWikipedia → const List<List>

strokeRoundedWindowsNew → const List<List>

strokeRoundedWindowsOld → const List<List>

strokeRoundedWindPower → const List<List>

strokeRoundedWindPower01 → const List<List>

strokeRoundedWindPower02 → const List<List>

strokeRoundedWindPower03 → const List<List>

strokeRoundedWindSurf → const List<List>

strokeRoundedWindTurbine → const List<List>

strokeRoundedWink → const List<List>

strokeRoundedWinking → const List<List>

strokeRoundedWireless → const List<List>

strokeRoundedWirelessCloudAccess → const List<List>

strokeRoundedWise → const List<List>

strokeRoundedWoman → const List<List>

strokeRoundedWordpress → const List<List>

strokeRoundedWork → const List<List>

strokeRoundedWorkAlert → const List<List>

strokeRoundedWorkflowCircle01 → const List<List>

strokeRoundedWorkflowCircle02 → const List<List>

strokeRoundedWorkflowCircle03 → const List<List>

strokeRoundedWorkflowCircle04 → const List<List>

strokeRoundedWorkflowCircle05 → const List<List>

strokeRoundedWorkflowCircle06 → const List<List>

strokeRoundedWorkflowSquare01 → const List<List>

strokeRoundedWorkflowSquare02 → const List<List>

strokeRoundedWorkflowSquare03 → const List<List>

strokeRoundedWorkflowSquare04 → const List<List>

strokeRoundedWorkflowSquare05 → const List<List>

strokeRoundedWorkflowSquare06 → const List<List>

strokeRoundedWorkflowSquare07 → const List<List>

strokeRoundedWorkflowSquare08 → const List<List>

strokeRoundedWorkflowSquare09 → const List<List>

strokeRoundedWorkflowSquare10 → const List<List>

strokeRoundedWorkHistory → const List<List>

strokeRoundedWorkoutBattleRopes → const List<List>

strokeRoundedWorkoutGymnastics → const List<List>

strokeRoundedWorkoutKicking → const List<List>

strokeRoundedWorkoutRun → const List<List>

strokeRoundedWorkoutSport → const List<List>

strokeRoundedWorkoutSquats → const List<List>

strokeRoundedWorkoutStretching → const List<List>

strokeRoundedWorkoutWarmUp → const List<List>

strokeRoundedWorkUpdate → const List<List>

strokeRoundedWorry → const List<List>

strokeRoundedWpsOffice → const List<List>

strokeRoundedWpsOfficeRectangle → const List<List>

strokeRoundedWrench01 → const List<List>

strokeRoundedWrench02 → const List<List>

strokeRoundedWudu → const List<List>

strokeRoundedXing → const List<List>

strokeRoundedXls01 → const List<List>

strokeRoundedXls02 → const List<List>

strokeRoundedXml01 → const List<List>

strokeRoundedXml02 → const List<List>

strokeRoundedXRay → const List<List>

strokeRoundedXsl01 → const List<List>

strokeRoundedXsl02 → const List<List>

strokeRoundedXVariable → const List<List>

strokeRoundedXVariableCircle → const List<List>

strokeRoundedXVariableSquare → const List<List>

strokeRoundedYelp → const List<List>

strokeRoundedYen → const List<List>

strokeRoundedYenCircle → const List<List>

strokeRoundedYenReceive → const List<List>

strokeRoundedYenSend → const List<List>

strokeRoundedYenSquare → const List<List>

strokeRoundedYoga01 → const List<List>

strokeRoundedYoga02 → const List<List>

strokeRoundedYoga03 → const List<List>

strokeRoundedYogaBall → const List<List>

strokeRoundedYogaMat → const List<List>

strokeRoundedYogurt → const List<List>

strokeRoundedYoutube → const List<List>

strokeRoundedYurt → const List<List>

strokeRoundedZakat → const List<List>

strokeRoundedZap → const List<List>

strokeRoundedZeppelin → const List<List>

strokeRoundedZeroCircle → const List<List>

strokeRoundedZeroSquare → const List<List>

strokeRoundedZip01 → const List<List>

strokeRoundedZip02 → const List<List>

strokeRoundedZoom → const List<List>

strokeRoundedZoomCircle → const List<List>

strokeRoundedZoomInArea → const List<List>

strokeRoundedZoomOutArea → const List<List>

strokeRoundedZoomSquare → const List<List>

strokeRoundedZsh → const List<List>

strokeRoundedZzz → const List<List>