Skip to content

Instantly share code, notes, and snippets.

@aloisdeniel

aloisdeniel/main.dart

Last active January 20, 2026 22:15
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save aloisdeniel/a9bf53eeec1f666f70277f07a7d4b37c to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save aloisdeniel/a9bf53eeec1f666f70277f07a7d4b37c to your computer and use it in GitHub Desktop.
Download ZIP
Flutter Codegen plugin for Figma / Vector Graphics
Raw
main.dart
import 'package:flutter/material.dart';
import 'dart:math' as math;
import 'dart:ui' as ui;
import 'dart:typed_data';
import 'package:flutter/widgets.dart' as fl;
void main() {
runApp(const MyApp());
}
class MyApp extends StatelessWidget {
const MyApp({super.key});
@override
Widget build(BuildContext context) {
return const MaterialApp(
debugShowCheckedModeBanner: false,
home: Scaffold(
body: Material(
color: Colors.white,
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
Camp(),
Bicycle(
styles: BicycleStyles(
// Overriding colors bound to variables
accent: BicycleAccentStyles(medium: Colors.amber),
),
),
],
),
),
),
);
}
}
// The code below is generated with the Flutter Codegen plugin for Figma
class BicycleStyles {
const BicycleStyles({
this.accent = const BicycleAccentStyles(),
});
final BicycleAccentStyles accent;
}
class BicycleAccentStyles {
const BicycleAccentStyles({
this.medium = const fl.Color.from(red: 0.26528695225715637, green: 0.3877391517162323, blue: 1, alpha: 1,colorSpace: ui.ColorSpace.extendedSRGB),
});
final fl.Color medium;
}
class Bicycle extends fl.StatelessWidget {
const Bicycle({super.key, this.styles = const BicycleStyles()});
final BicycleStyles styles;
@override
fl.Widget build(fl.BuildContext context) {
return fl.CustomPaint(size: const fl.Size(500.000000, 500.000000), painter: BicyclePainter(styles));
}
}
class BicyclePainter extends fl.CustomPainter {
const BicyclePainter(this.styles);
final BicycleStyles styles;
@override
void paint(ui.Canvas canvas, fl.Size size) {
final paint = ui.Paint();
final bounds = fl.Offset.zero & size;
_frame_0_bicycle(canvas, bounds, paint);
}
@pragma('vm:prefer-inline')
void _frame_0_bicycle(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
{
final rect = fl.Rect.fromLTWH(0, 0, 500.000000, 500.000000);
final rrect = fl.RRect.fromRectAndCorners(rect, topLeft: fl.Radius.circular(0.000000), topRight: fl.Radius.circular(0.000000), bottomLeft: fl.Radius.circular(0.000000), bottomRight: fl.Radius.circular(0.000000));
canvas.clipRRect(rrect);
}
_group_1_sdBicycle17(canvas, bounds, paint);
_group_2_bikeBicycle17(canvas, bounds, paint);
canvas.restore();
}
@pragma('vm:prefer-inline')
void _group_1_sdBicycle17(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.saveLayer(bounds, ui.Paint()..color = ui.Color.fromRGBO(255, 255, 255, 0.300000));
_network_3_shadow(canvas, bounds, paint);
canvas.restore();
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_3_shadow(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 28.129999, 447.970001, 0, 1]));
{
final path = ui.Path();
{
path.moveTo(443.739990, 18.970001);
path.cubicTo(443.739990, 29.446843, 344.405411, 37.940002, 221.869995, 37.940002);
path.cubicTo(99.334579, 37.940002, 0.000000, 29.446843, 0.000000, 18.970001);
path.cubicTo(0.000000, 8.493159, 99.334579, 0.000000, 221.869995, 0.000000);
path.cubicTo(344.405411, 0.000000, 443.739990, 8.493159, 443.739990, 18.970001);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.901961, green: 0.901961, blue: 0.901961, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _group_2_bikeBicycle17(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
_network_4_vector(canvas, bounds, paint);
_group_5_group(canvas, bounds, paint);
_network_6_vector(canvas, bounds, paint);
_group_7_group(canvas, bounds, paint);
_network_8_vector(canvas, bounds, paint);
_network_9_vector(canvas, bounds, paint);
_network_10_vector(canvas, bounds, paint);
_network_11_vector(canvas, bounds, paint);
_group_12_group(canvas, bounds, paint);
_network_13_vector(canvas, bounds, paint);
_network_14_vector(canvas, bounds, paint);
_network_15_vector(canvas, bounds, paint);
_network_16_vector(canvas, bounds, paint);
_network_17_vector(canvas, bounds, paint);
_network_18_vector(canvas, bounds, paint);
_network_19_vector(canvas, bounds, paint);
_network_20_vector(canvas, bounds, paint);
_network_21_vector(canvas, bounds, paint);
_network_22_vector(canvas, bounds, paint);
_network_23_vector(canvas, bounds, paint);
_network_24_vector(canvas, bounds, paint);
_network_25_vector(canvas, bounds, paint);
_group_26_group(canvas, bounds, paint);
_network_27_vector(canvas, bounds, paint);
_network_28_vector(canvas, bounds, paint);
_network_29_vector(canvas, bounds, paint);
_network_30_vector(canvas, bounds, paint);
_group_31_group(canvas, bounds, paint);
_network_32_vector(canvas, bounds, paint);
_network_33_vector(canvas, bounds, paint);
_network_34_vector(canvas, bounds, paint);
_network_35_vector(canvas, bounds, paint);
_network_36_vector(canvas, bounds, paint);
_network_37_line(canvas, bounds, paint);
_network_38_line2(canvas, bounds, paint);
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_4_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 241.820004, 232.830008, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(34.869995, 0.000000);
path.cubicTo(34.869995, 0.000000, 81.889999, 26.959995, 65.029999, 58.229996);
path.cubicTo(48.169998, 89.499996, 20.769989, 97.409988, 20.769989, 97.409988);
path.cubicTo(20.769989, 97.409988, 0.000000, 0.009995, 0.000000, 0.009995);
path.cubicTo(0.000000, 0.009995, 34.859985, 0.009995, 34.859985, 0.009995);
path.cubicTo(34.859985, 0.009995, 34.869995, 0.000000, 34.869995, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.141176, green: 0.156863, blue: 0.356863, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _group_5_group(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.saveLayer(bounds, ui.Paint()..color = ui.Color.fromRGBO(255, 255, 255, 0.080000));
_network_39_vector(canvas, bounds, paint);
canvas.restore();
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_39_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 241.820004, 232.830008, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(34.869995, 0.000000);
path.cubicTo(34.869995, 0.000000, 81.889999, 26.959995, 65.029999, 58.229996);
path.cubicTo(48.169998, 89.499996, 20.769989, 97.409988, 20.769989, 97.409988);
path.cubicTo(20.769989, 97.409988, 0.000000, 0.009995, 0.000000, 0.009995);
path.cubicTo(0.000000, 0.009995, 34.859985, 0.009995, 34.859985, 0.009995);
path.cubicTo(34.859985, 0.009995, 34.869995, 0.000000, 34.869995, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.000000, green: 0.000000, blue: 0.003922, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_6_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 235.719997, 198.679998, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(13.350006, 0.000000);
path.cubicTo(13.350006, 0.000000, 44.859993, 9.740013, 61.179993, 15.810013);
path.cubicTo(77.499992, 21.880013, 84.380009, 38.440012, 70.040009, 39.700012);
path.cubicTo(55.700008, 40.960012, 56.989990, 31.260010, 56.989990, 31.260010);
path.cubicTo(56.989990, 31.260010, 18.959991, 26.550003, 18.959991, 26.550003);
path.cubicTo(18.959991, 26.550003, 0.000000, 19.910004, 0.000000, 19.910004);
path.cubicTo(0.000000, 19.910004, 13.350006, 0.000000, 13.350006, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.956863, green: 0.635294, blue: 0.549020, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _group_7_group(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.saveLayer(bounds, ui.Paint()..color = ui.Color.fromRGBO(255, 255, 255, 0.080000));
_network_40_vector(canvas, bounds, paint);
canvas.restore();
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_40_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 235.719997, 198.679998, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(13.350006, 0.000000);
path.cubicTo(13.350006, 0.000000, 44.859993, 9.740013, 61.179993, 15.810013);
path.cubicTo(77.499992, 21.880013, 84.380009, 38.440012, 70.040009, 39.700012);
path.cubicTo(55.700008, 40.960012, 56.989990, 31.260010, 56.989990, 31.260010);
path.cubicTo(56.989990, 31.260010, 18.959991, 26.550003, 18.959991, 26.550003);
path.cubicTo(18.959991, 26.550003, 0.000000, 19.910004, 0.000000, 19.910004);
path.cubicTo(0.000000, 19.910004, 13.350006, 0.000000, 13.350006, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.000000, green: 0.000000, blue: 0.003922, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_8_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 63.009998, 312.880011, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(76.260010, 152.519989);
path.cubicTo(34.210011, 152.519989, 0.000000, 118.310009, 0.000000, 76.260010);
path.cubicTo(0.000000, 34.210011, 34.210011, 0.000000, 76.260010, 0.000000);
path.cubicTo(118.310009, 0.000000, 152.520004, 34.210011, 152.520004, 76.260010);
path.cubicTo(152.520004, 118.310009, 118.310009, 152.519989, 76.260010, 152.519989);
path.close();
}
{
path.moveTo(76.260010, 8.440002);
path.cubicTo(38.870010, 8.440002, 8.450001, 38.860001, 8.450001, 76.250000);
path.cubicTo(8.450001, 113.639999, 38.870010, 144.059998, 76.260010, 144.059998);
path.cubicTo(113.650009, 144.059998, 144.070007, 113.639999, 144.070007, 76.250000);
path.cubicTo(144.070007, 38.860001, 113.650009, 8.440002, 76.260010, 8.440002);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.141176, green: 0.156863, blue: 0.356863, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_9_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 50.020000, 299.900000, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(175.309998, 92.410004);
path.cubicTo(173.559998, 92.410004, 172.139999, 90.990021, 172.139999, 89.240021);
path.cubicTo(172.139999, 43.530022, 134.949989, 6.339996, 89.239990, 6.339996);
path.cubicTo(43.529991, 6.339996, 6.340000, 43.530022, 6.340000, 89.240021);
path.cubicTo(6.340000, 90.990021, 4.919998, 92.410004, 3.169998, 92.410004);
path.cubicTo(1.419998, 92.410004, 0.000000, 90.990021, 0.000000, 89.240021);
path.cubicTo(0.000000, 40.040020, 40.029995, 0.000000, 89.229996, 0.000000);
path.cubicTo(138.429996, 0.000000, 178.459991, 40.030022, 178.459991, 89.240021);
path.cubicTo(178.459991, 90.990021, 177.039993, 92.410004, 175.289993, 92.410004);
path.cubicTo(175.289993, 92.410004, 175.309998, 92.410004, 175.309998, 92.410004);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.407843, green: 0.882353, blue: 0.992157, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_10_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 279.719997, 299.900000, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(175.309998, 92.410004);
path.cubicTo(173.559998, 92.410004, 172.139984, 90.990021, 172.139984, 89.240021);
path.cubicTo(172.139984, 43.530022, 134.949989, 6.339996, 89.239990, 6.339996);
path.cubicTo(43.529991, 6.339996, 6.339996, 43.530022, 6.339996, 89.240021);
path.cubicTo(6.339996, 90.990021, 4.920013, 92.410004, 3.170013, 92.410004);
path.cubicTo(1.420013, 92.410004, 0.000000, 90.990021, 0.000000, 89.240021);
path.cubicTo(0.000000, 40.040020, 40.029991, 0.000000, 89.239990, 0.000000);
path.cubicTo(138.449989, 0.000000, 178.470001, 40.030022, 178.470001, 89.240021);
path.cubicTo(178.470001, 90.990021, 177.049988, 92.410004, 175.299988, 92.410004);
path.cubicTo(175.299988, 92.410004, 175.309998, 92.410004, 175.309998, 92.410004);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.407843, green: 0.882353, blue: 0.992157, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_11_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 136.593548, 376.868505, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(12.766454, 0.011491);
path.cubicTo(12.766454, 0.011491, 96.316460, 1.301500, 96.316460, 1.301500);
path.cubicTo(108.816460, 1.491500, 118.806459, 12.511477, 116.956459, 24.871477);
path.cubicTo(116.866459, 25.441477, 116.766452, 26.011488, 116.636452, 26.601488);
path.cubicTo(116.256452, 28.381488, 115.726458, 29.991475, 115.096458, 31.431475);
path.cubicTo(111.146458, 40.451475, 101.066459, 45.111481, 91.456459, 42.971481);
path.cubicTo(91.456459, 42.971481, 9.856450, 24.851488, 9.856450, 24.851488);
path.cubicTo(2.996450, 23.331488, -1.283544, 16.491485, 0.346456, 9.661485);
path.cubicTo(1.716456, 3.931485, 6.876448, -0.088519, 12.776448, 0.001481);
path.cubicTo(12.776448, 0.001481, 12.766454, 0.011491, 12.766454, 0.011491);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.407843, green: 0.882353, blue: 0.992157, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _group_12_group(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.saveLayer(bounds, ui.Paint()..color = ui.Color.fromRGBO(255, 255, 255, 0.440000));
_network_41_vector(canvas, bounds, paint);
canvas.restore();
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_41_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 136.593548, 376.868505, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(12.766454, 0.011491);
path.cubicTo(12.766454, 0.011491, 96.316460, 1.301500, 96.316460, 1.301500);
path.cubicTo(108.816460, 1.491500, 118.806459, 12.511477, 116.956459, 24.871477);
path.cubicTo(116.866459, 25.441477, 116.766452, 26.011488, 116.636452, 26.601488);
path.cubicTo(116.256452, 28.381488, 115.726458, 29.991475, 115.096458, 31.431475);
path.cubicTo(111.146458, 40.451475, 101.066459, 45.111481, 91.456459, 42.971481);
path.cubicTo(91.456459, 42.971481, 9.856450, 24.851488, 9.856450, 24.851488);
path.cubicTo(2.996450, 23.331488, -1.283544, 16.491485, 0.346456, 9.661485);
path.cubicTo(1.716456, 3.931485, 6.876448, -0.088519, 12.776448, 0.001481);
path.cubicTo(12.776448, 0.001481, 12.766454, 0.011491, 12.766454, 0.011491);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 1.000000, green: 1.000000, blue: 1.000000, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_13_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 292.709988, 312.880011, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(76.260010, 152.519989);
path.cubicTo(34.210011, 152.519989, 0.000000, 118.310009, 0.000000, 76.260010);
path.cubicTo(0.000000, 34.210011, 34.210011, 0.000000, 76.260010, 0.000000);
path.cubicTo(118.310009, 0.000000, 152.520020, 34.210011, 152.520020, 76.260010);
path.cubicTo(152.520020, 118.310009, 118.310009, 152.519989, 76.260010, 152.519989);
path.close();
}
{
path.moveTo(76.260010, 8.440002);
path.cubicTo(38.870010, 8.440002, 8.450012, 38.860001, 8.450012, 76.250000);
path.cubicTo(8.450012, 113.639999, 38.870010, 144.059998, 76.260010, 144.059998);
path.cubicTo(113.650009, 144.059998, 144.070007, 113.639999, 144.070007, 76.250000);
path.cubicTo(144.070007, 38.860001, 113.650009, 8.440002, 76.260010, 8.440002);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.141176, green: 0.156863, blue: 0.356863, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_14_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 119.430004, 369.299994, 0, 1]));
{
final path = ui.Path();
{
path.moveTo(39.680000, 19.840027);
path.cubicTo(39.680000, 30.797357, 30.797334, 39.680023, 19.840004, 39.680023);
path.cubicTo(8.882674, 39.680023, 0.000000, 30.797357, 0.000000, 19.840027);
path.cubicTo(0.000000, 8.882697, 8.882674, 0.000000, 19.840004, 0.000000);
path.cubicTo(30.797334, 0.000000, 39.680000, 8.882697, 39.680000, 19.840027);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.141176, green: 0.156863, blue: 0.356863, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_15_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 346.840008, 369.299994, 0, 1]));
{
final path = ui.Path();
{
path.moveTo(39.679993, 19.840027);
path.cubicTo(39.679993, 30.797357, 30.797326, 39.680023, 19.839996, 39.680023);
path.cubicTo(8.882667, 39.680023, 0.000000, 30.797357, 0.000000, 19.840027);
path.cubicTo(0.000000, 8.882697, 8.882667, 0.000000, 19.839996, 0.000000);
path.cubicTo(30.797326, 0.000000, 39.679993, 8.882697, 39.679993, 19.840027);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.141176, green: 0.156863, blue: 0.356863, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_16_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 217.183956, 276.706244, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(3.166047, 78.173767);
path.cubicTo(1.866047, 78.173767, 0.646036, 77.363751, 0.186036, 76.063751);
path.cubicTo(-0.403964, 74.413751, 0.456034, 72.603763, 2.106034, 72.013763);
path.cubicTo(2.746034, 71.783763, 66.256042, 48.733770, 101.506042, 1.273771);
path.cubicTo(102.546042, -0.126229, 104.536035, -0.416253, 105.936035, 0.623747);
path.cubicTo(107.336035, 1.663747, 107.636029, 3.653770, 106.586029, 5.053770);
path.cubicTo(70.166031, 54.093771, 6.906045, 77.033765, 4.226045, 77.983765);
path.cubicTo(3.876045, 78.103765, 3.516047, 78.163757, 3.166047, 78.163757);
path.cubicTo(3.166047, 78.163757, 3.166047, 78.173767, 3.166047, 78.173767);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.407843, green: 0.882353, blue: 0.992157, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_17_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 289.536465, 221.224752, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(77.143509, 171.085251);
path.cubicTo(76.443509, 171.085251, 75.733509, 170.855259, 75.143509, 170.375259);
path.cubicTo(48.483509, 148.655260, 21.983512, 30.985258, 20.863512, 25.985258);
path.cubicTo(20.663512, 25.105258, 20.863532, 24.185250, 21.383532, 23.445250);
path.cubicTo(21.903532, 22.705250, 22.723522, 22.235247, 23.623522, 22.145247);
path.cubicTo(28.873522, 21.575247, 44.063519, 18.295252, 44.993519, 10.885252);
path.cubicTo(45.013519, 10.695252, 45.043531, 10.525251, 44.693531, 10.165251);
path.cubicTo(40.493531, 5.835251, 18.063519, 5.805245, 3.463518, 7.175245);
path.cubicTo(1.743518, 7.335245, 0.183506, 6.055245, 0.013506, 4.315245);
path.cubicTo(-0.146494, 2.575245, 1.133522, 1.025248, 2.873522, 0.865248);
path.cubicTo(9.243522, 0.265248, 41.423509, -2.304753, 49.233509, 5.755247);
path.cubicTo(50.843509, 7.415247, 51.543518, 9.455251, 51.273518, 11.665251);
path.cubicTo(49.893518, 22.685251, 34.953524, 26.655245, 27.813524, 27.925245);
path.cubicTo(32.383524, 47.475245, 56.543509, 147.045256, 79.143509, 165.465256);
path.cubicTo(80.503509, 166.575256, 80.703531, 168.565247, 79.603531, 169.925247);
path.cubicTo(78.973531, 170.695247, 78.063509, 171.095261, 77.143509, 171.095261);
path.cubicTo(77.143509, 171.095261, 77.143509, 171.085251, 77.143509, 171.085251);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.407843, green: 0.882353, blue: 0.992157, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_18_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 327.200024, 245.929998, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(0.000000, 11.860016);
path.cubicTo(0.000000, 11.860016, 51.529999, 0.000000, 51.529999, 0.000000);
path.cubicTo(51.529999, 0.000000, 56.159973, 47.089996, 56.159973, 47.089996);
path.cubicTo(56.159973, 47.089996, 11.509979, 55.429993, 11.509979, 55.429993);
path.cubicTo(11.509979, 55.429993, 0.000000, 11.860016, 0.000000, 11.860016);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = styles.accent.medium.withValues(alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_19_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 136.926601, 279.476904, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(106.473389, 122.313095);
path.cubicTo(106.273389, 122.313095, 106.063388, 122.293098, 105.863388, 122.253098);
path.cubicTo(104.763388, 122.033098, 103.863393, 121.253079, 103.493393, 120.203079);
path.cubicTo(103.493393, 120.203079, 64.653397, 10.613084, 64.653397, 10.613084);
path.cubicTo(64.653397, 10.613084, 5.893405, 109.823074, 5.893405, 109.823074);
path.cubicTo(5.003405, 111.333074, 3.053393, 111.823090, 1.553393, 110.933090);
path.cubicTo(0.043393, 110.043090, -0.446607, 108.103094, 0.443393, 106.593094);
path.cubicTo(0.443393, 106.593094, 62.653400, 1.553086, 62.653400, 1.553086);
path.cubicTo(63.283400, 0.493086, 64.443395, -0.096922, 65.683395, 0.013078);
path.cubicTo(66.903395, 0.133078, 67.953388, 0.953084, 68.363388, 2.113084);
path.cubicTo(68.363388, 2.113084, 107.683395, 113.053085, 107.683395, 113.053085);
path.cubicTo(107.683395, 113.053085, 188.053406, 25.193102, 188.053406, 25.193102);
path.cubicTo(189.223406, 23.893102, 191.213407, 23.773102, 192.523407, 24.943102);
path.cubicTo(193.823407, 26.113102, 193.933407, 28.113103, 192.773407, 29.413103);
path.cubicTo(192.773407, 29.413103, 108.833389, 121.253098, 108.833389, 121.253098);
path.cubicTo(108.223389, 121.933098, 107.363389, 122.303085, 106.473389, 122.303085);
path.cubicTo(106.473389, 122.303085, 106.473389, 122.313095, 106.473389, 122.313095);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.407843, green: 0.882353, blue: 0.992157, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_20_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 285.130001, 219.110006, 0, 1]));
{
final path = ui.Path();
{
path.moveTo(4.119995, 0.000000);
path.cubicTo(4.119995, 0.000000, 26.179993, 0.000000, 26.179993, 0.000000);
path.cubicTo(28.455406, 0.000000, 30.299988, 1.844582, 30.299988, 4.119995);
path.cubicTo(30.299988, 4.119995, 30.299988, 8.130005, 30.299988, 8.130005);
path.cubicTo(30.299988, 10.405418, 28.455406, 12.250000, 26.179993, 12.250000);
path.cubicTo(26.179993, 12.250000, 4.119995, 12.250000, 4.119995, 12.250000);
path.cubicTo(1.844582, 12.250000, 0.000000, 10.405418, 0.000000, 8.130005);
path.cubicTo(0.000000, 8.130005, 0.000000, 4.119995, 0.000000, 4.119995);
path.cubicTo(0.000000, 1.844582, 1.844582, 0.000000, 4.119995, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.141176, green: 0.156863, blue: 0.356863, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_21_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 197.909359, 257.579992, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(4.580635, 30.410004);
path.cubicTo(2.280635, 30.410004, 0.400634, 28.570010, 0.360634, 26.260010);
path.cubicTo(0.360634, 26.260010, 0.000633, 4.290009, 0.000633, 4.290009);
path.cubicTo(-0.039367, 1.960009, 1.820627, 0.040000, 4.150627, 0.000000);
path.cubicTo(4.170627, 0.000000, 4.200634, 0.000000, 4.220634, 0.000000);
path.cubicTo(6.520634, 0.000000, 8.400636, 1.840024, 8.440636, 4.150024);
path.cubicTo(8.440636, 4.150024, 8.800636, 26.120026, 8.800636, 26.120026);
path.cubicTo(8.840636, 28.450026, 6.980627, 30.370004, 4.650627, 30.410004);
path.cubicTo(4.630627, 30.410004, 4.600635, 30.410004, 4.580635, 30.410004);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.407843, green: 0.882353, blue: 0.992157, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_22_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 183.104916, 256.218328, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(4.195086, 3.861660);
path.cubicTo(-1.364914, 6.311660, -1.414917, 14.121683, 4.145083, 16.541683);
path.cubicTo(6.445083, 17.541683, 9.545090, 18.361683, 13.715090, 18.791683);
path.cubicTo(27.065090, 20.191683, 43.055079, 17.321671, 51.015079, 15.591671);
path.cubicTo(53.845079, 14.981671, 55.695090, 12.251659, 55.245090, 9.391659);
path.cubicTo(54.935090, 7.421659, 53.575087, 5.781681, 51.695087, 5.101681);
path.cubicTo(43.835087, 2.261681, 22.285086, -4.098340, 4.195086, 3.861660);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = styles.accent.medium.withValues(alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
{
final path = ui.Path();
path.moveTo(4.195086, 3.861660);
path.cubicTo(-1.364914, 6.311660, -1.414917, 14.121683, 4.145083, 16.541683);
path.cubicTo(6.445083, 17.541683, 9.545090, 18.361683, 13.715090, 18.791683);
path.cubicTo(27.065090, 20.191683, 43.055079, 17.321671, 51.015079, 15.591671);
path.cubicTo(53.845079, 14.981671, 55.695090, 12.251659, 55.245090, 9.391659);
path.cubicTo(54.935090, 7.421659, 53.575087, 5.781681, 51.695087, 5.101681);
path.cubicTo(43.835087, 2.261681, 22.285086, -4.098340, 4.195086, 3.861660);
paint.style = ui.PaintingStyle.stroke;
paint.strokeWidth = 1.000000;
paint
..blendMode = ui.BlendMode.srcOver
..color = styles.accent.medium.withValues(alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_23_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 246.194927, 22.352114, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(21.005087, 8.627885);
path.cubicTo(21.005087, 8.627885, 22.325070, 19.727887, 20.675070, 27.187887);
path.cubicTo(20.005070, 30.217887, 16.965069, 32.157885, 13.955069, 31.447886);
path.cubicTo(10.205069, 30.567886, 5.405072, 28.287885, 3.975072, 22.427885);
path.cubicTo(3.975072, 22.427885, 0.335073, 12.777886, 0.335073, 12.777886);
path.cubicTo(0.335073, 12.777886, -1.734925, 6.647886, 4.415075, 1.927886);
path.cubicTo(10.575075, -2.802114, 20.545087, 1.837885, 21.005087, 8.637885);
path.cubicTo(21.005087, 8.637885, 21.005087, 8.627885, 21.005087, 8.627885);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.956863, green: 0.635294, blue: 0.549020, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_24_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 236.999996, 36.389999, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(14.210007, 0.000000);
path.cubicTo(14.210007, 0.000000, 0.000000, 33.750000, 0.000000, 33.750000);
path.cubicTo(0.000000, 33.750000, 19.019989, 41.739998, 19.019989, 41.739998);
path.cubicTo(19.019989, 41.739998, 21.739990, 13.760002, 21.739990, 13.760002);
path.cubicTo(21.739990, 13.760002, 14.210007, 0.000000, 14.210007, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.956863, green: 0.635294, blue: 0.549020, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_25_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 265.640011, 38.009998, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(2.029999, 0.000000);
path.cubicTo(2.029999, 0.000000, 5.279999, 4.210003, 5.279999, 4.210003);
path.cubicTo(6.079999, 5.250003, 5.530000, 6.770003, 4.250000, 7.050003);
path.cubicTo(4.250000, 7.050003, 0.000000, 7.990002, 0.000000, 7.990002);
path.cubicTo(0.000000, 7.990002, 2.029999, 0.010002, 2.029999, 0.010002);
path.cubicTo(2.029999, 0.010002, 2.029999, 0.000000, 2.029999, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.956863, green: 0.635294, blue: 0.549020, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _group_26_group(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.saveLayer(bounds, ui.Paint()..color = ui.Color.fromRGBO(255, 255, 255, 0.310000));
_network_42_vector(canvas, bounds, paint);
canvas.restore();
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_42_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 252.022686, 48.870001, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(6.507310, 3.650002);
path.cubicTo(6.507310, 3.650002, 3.877305, 2.610000, 1.767305, 0.000000);
path.cubicTo(1.767305, 0.000000, -4.022684, 11.720004, 5.357316, 15.180004);
path.cubicTo(5.357316, 15.180004, 6.507310, 3.650002, 6.507310, 3.650002);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.807843, green: 0.505882, blue: 0.447059, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_27_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 249.065990, 35.399773, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(5.604001, 3.900226);
path.cubicTo(5.604001, 3.900226, 5.383998, -0.399773, 2.163998, 0.030227);
path.cubicTo(-1.056002, 0.460227, -0.776000, 6.670227, 3.633999, 7.120227);
path.cubicTo(3.633999, 7.120227, 5.604001, 3.900226, 5.604001, 3.900226);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.956863, green: 0.635294, blue: 0.549020, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_28_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 180.513760, 213.150000, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(7.276227, 0.000000);
path.cubicTo(7.276227, 0.000000, -13.253769, 36.020016, 14.656231, 44.360016);
path.cubicTo(42.566231, 52.700016, 70.796233, 74.030012, 56.486233, 103.950012);
path.cubicTo(42.176232, 133.870012, 37.546230, 150.850006, 37.546230, 150.850006);
path.cubicTo(37.546230, 150.850006, 90.776245, 160.040009, 90.776245, 160.040009);
path.cubicTo(90.776245, 160.040009, 122.346245, 54.940006, 94.306244, 37.240005);
path.cubicTo(66.266243, 19.540005, 56.486233, 12.100006, 56.486233, 12.100006);
path.cubicTo(56.486233, 12.100006, 7.276227, 0.010010, 7.276227, 0.010010);
path.cubicTo(7.276227, 0.010010, 7.276227, 0.000000, 7.276227, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.141176, green: 0.156863, blue: 0.356863, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_29_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 247.720959, 34.253040, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(7.349049, 3.876961);
path.cubicTo(7.349049, 3.876961, 6.319034, -1.003041, 2.459034, 0.186959);
path.cubicTo(-1.400966, 1.376959, -0.710952, 7.156962, 4.489048, 8.896962);
path.cubicTo(4.489048, 8.896962, 7.349049, 3.876961, 7.349049, 3.876961);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.956863, green: 0.635294, blue: 0.549020, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_30_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 163.212337, 65.323233, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(70.137665, 3.536763);
path.cubicTo(70.137665, 3.536763, 78.777664, 6.406766, 78.777664, 6.406766);
path.cubicTo(88.827664, 9.746766, 97.907652, 15.496760, 105.187653, 23.196760);
path.cubicTo(120.297652, 39.176760, 141.877661, 68.026764, 130.477661, 93.206764);
path.cubicTo(113.657661, 130.366764, 73.867661, 157.096756, 73.867661, 157.096756);
path.cubicTo(73.867661, 157.096756, 2.037656, 133.336761, 2.037656, 133.336761);
path.cubicTo(2.037656, 133.336761, -18.392342, -25.493235, 70.127655, 3.546766);
path.cubicTo(70.127655, 3.546766, 70.137665, 3.536763, 70.137665, 3.536763);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.407843, green: 0.882353, blue: 0.992157, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _group_31_group(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.saveLayer(bounds, ui.Paint()..color = ui.Color.fromRGBO(255, 255, 255, 0.080000));
_network_43_vector(canvas, bounds, paint);
canvas.restore();
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_43_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 193.299999, 102.779997, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(60.739990, 0.000000);
path.cubicTo(60.739990, 0.000000, 83.619991, 26.739998, 54.569992, 58.809998);
path.cubicTo(25.529991, 90.879997, 34.149994, 110.380005, 34.149994, 110.380005);
path.cubicTo(34.149994, 110.380005, 0.000000, 77.580002, 0.000000, 77.580002);
path.cubicTo(0.000000, 77.580002, 60.729996, 0.000000, 60.729996, 0.000000);
path.cubicTo(60.729996, 0.000000, 60.739990, 0.000000, 60.739990, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.000000, green: 0.000000, blue: 0.003922, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_32_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 152.888287, 82.016630, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(92.981697, 7.393374);
path.cubicTo(79.221697, -4.056626, 58.621700, -1.876626, 46.891701, 11.643374);
path.cubicTo(19.861700, 42.773374, -28.278292, 108.483376, 21.851709, 133.553375);
path.cubicTo(88.571711, 166.913376, 137.401718, 153.863373, 137.401718, 153.863373);
path.cubicTo(137.401718, 153.863373, 147.151720, 163.813362, 152.871719, 156.383362);
path.cubicTo(158.591719, 148.943362, 140.501703, 137.753363, 130.011703, 137.103363);
path.cubicTo(119.521704, 136.453363, 57.151707, 120.503361, 54.241707, 101.163361);
path.cubicTo(51.791707, 84.843361, 125.971699, 34.823374, 92.981697, 7.393374);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.956863, green: 0.635294, blue: 0.549020, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_33_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 159.452938, 14.087988, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(95.217056, 25.212011);
path.cubicTo(95.217056, 25.212011, 97.827055, 50.882011, 85.247055, 60.952011);
path.cubicTo(72.667055, 71.012012, 61.167051, 54.412006, 44.637051, 67.932007);
path.cubicTo(28.107050, 81.442007, 15.747051, 84.972008, 3.777050, 67.932007);
path.cubicTo(-8.192950, 50.892006, 9.777058, 27.722014, 36.737057, 29.062014);
path.cubicTo(60.717056, 30.252014, 80.717059, 30.952011, 80.157059, 18.192011);
path.cubicTo(79.727059, 8.272011, 87.177046, -0.497988, 97.097046, 0.022012);
path.cubicTo(99.777046, 0.162012, 102.797052, 0.872011, 106.197052, 2.372011);
path.cubicTo(126.597052, 11.362011, 95.237061, 25.222013, 95.237061, 25.222013);
path.cubicTo(95.237061, 25.222013, 95.217056, 25.212011, 95.217056, 25.212011);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.141176, green: 0.156863, blue: 0.356863, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_34_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 238.410000, 368.459997, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(5.539993, 0.000000);
path.cubicTo(5.539993, 0.000000, 0.000000, 24.309998, 0.000000, 24.309998);
path.cubicTo(0.000000, 24.309998, 14.789993, 26.830017, 14.789993, 26.830017);
path.cubicTo(14.789993, 26.830017, 24.190002, 3.220001, 24.190002, 3.220001);
path.cubicTo(24.190002, 3.220001, 5.539993, 0.000000, 5.539993, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.956863, green: 0.635294, blue: 0.549020, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_35_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 234.529995, 392.743841, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(3.880005, 0.026162);
path.cubicTo(3.880005, 0.026162, 0.000000, 12.246163, 0.000000, 12.246163);
path.cubicTo(0.000000, 12.246163, 31.380005, 13.686166, 31.380005, 13.686166);
path.cubicTo(31.380005, 13.686166, 30.300005, -0.693838, 3.880005, 0.026162);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.407843, green: 0.882353, blue: 0.992157, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_36_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 226.549999, 404.540014, 0, 1]));
{
final path = ui.Path();
{
path.moveTo(4.169998, 0.000000);
path.cubicTo(4.169998, 0.000000, 29.529984, 0.000000, 29.529984, 0.000000);
path.cubicTo(31.833011, 0.000000, 33.699997, 1.866956, 33.699997, 4.169983);
path.cubicTo(33.699997, 4.169983, 33.699997, 8.229980, 33.699997, 8.229980);
path.cubicTo(33.699997, 10.533008, 31.833011, 12.399994, 29.529984, 12.399994);
path.cubicTo(29.529984, 12.399994, 4.169998, 12.399994, 4.169998, 12.399994);
path.cubicTo(1.866971, 12.399994, 0.000000, 10.533008, 0.000000, 8.229980);
path.cubicTo(0.000000, 8.229980, 0.000000, 4.169983, 0.000000, 4.169983);
path.cubicTo(0.000000, 1.866956, 1.866971, 0.000000, 4.169998, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.141176, green: 0.156863, blue: 0.356863, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_37_line(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 346.000011, 21.000000, 0, 1]));
{
final path = ui.Path();
path.moveTo(98.500000, 0.000000);
path.cubicTo(70.000000, 35.500000, 26.590488, 25.599361, 8.500000, 65.000000);
path.cubicTo(-2.505221, 88.969101, 21.000000, 112.000000, 0.000000, 132.000000);
paint.style = ui.PaintingStyle.stroke;
paint.strokeWidth = 7.000000;
paint
..blendMode = ui.BlendMode.srcOver
..color = styles.accent.medium.withValues(alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_38_line2(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[0.981627, 0.190809, 0, 0, -0.190809, 0.981627, 0, 0, 0, 0, 1, 0, 361.428082, 142.397268, 0, 1]));
{
final path = ui.Path();
path.moveTo(0.000000, 29.000000);
path.cubicTo(0.000000, 29.000000, 72.000000, 0.000000, 72.000000, 0.000000);
paint.style = ui.PaintingStyle.stroke;
paint.strokeWidth = 7.000000;
paint
..blendMode = ui.BlendMode.srcOver
..color = styles.accent.medium.withValues(alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@override
bool shouldRepaint(covariant BicyclePainter oldDelegate) => false;
}
class CampStyles {
const CampStyles({
this.accent = const CampAccentStyles(),
});
final CampAccentStyles accent;
}
class CampAccentStyles {
const CampAccentStyles({
this.light = const fl.Color.from(red: 0.9249361753463745, green: 0.9374467730522156, blue: 1, alpha: 1,colorSpace: ui.ColorSpace.extendedSRGB),
this.medium = const fl.Color.from(red: 0.26528695225715637, green: 0.3877391517162323, blue: 1, alpha: 1,colorSpace: ui.ColorSpace.extendedSRGB),
this.dark = const fl.Color.from(red: 0.16449296474456787, green: 0.2027168571949005, blue: 0.3938363790512085, alpha: 1,colorSpace: ui.ColorSpace.extendedSRGB),
});
final fl.Color light;
final fl.Color medium;
final fl.Color dark;
}
class Camp extends fl.StatelessWidget {
const Camp({super.key, this.styles = const CampStyles()});
final CampStyles styles;
@override
fl.Widget build(fl.BuildContext context) {
return fl.CustomPaint(size: const fl.Size(454.000000, 341.000000), painter: CampPainter(styles));
}
}
class CampPainter extends fl.CustomPainter {
const CampPainter(this.styles);
final CampStyles styles;
@override
void paint(ui.Canvas canvas, fl.Size size) {
final paint = ui.Paint();
final bounds = fl.Offset.zero & size;
_frame_0_camp(canvas, bounds, paint);
}
@pragma('vm:prefer-inline')
void _frame_0_camp(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
{
final rect = fl.Rect.fromLTWH(0, 0, 454.000000, 341.000000);
final rrect = fl.RRect.fromRectAndCorners(rect, topLeft: fl.Radius.circular(0.000000), topRight: fl.Radius.circular(0.000000), bottomLeft: fl.Radius.circular(0.000000), bottomRight: fl.Radius.circular(0.000000));
canvas.clipRRect(rrect);
}
_network_1_vector(canvas, bounds, paint);
_network_2_vector(canvas, bounds, paint);
_network_3_vector(canvas, bounds, paint);
_network_4_vector(canvas, bounds, paint);
_network_5_vector(canvas, bounds, paint);
_network_6_vector(canvas, bounds, paint);
_network_7_vector(canvas, bounds, paint);
_network_8_vector(canvas, bounds, paint);
_network_9_vector(canvas, bounds, paint);
_network_10_vector(canvas, bounds, paint);
_network_11_vector(canvas, bounds, paint);
_network_12_vector(canvas, bounds, paint);
_network_13_vector(canvas, bounds, paint);
_network_14_vector(canvas, bounds, paint);
_network_15_vector(canvas, bounds, paint);
_network_16_vector(canvas, bounds, paint);
_network_17_vector(canvas, bounds, paint);
_network_18_vector(canvas, bounds, paint);
_network_19_vector(canvas, bounds, paint);
_network_20_vector(canvas, bounds, paint);
_network_21_vector(canvas, bounds, paint);
_network_22_vector(canvas, bounds, paint);
_network_23_vector(canvas, bounds, paint);
_network_24_vector(canvas, bounds, paint);
_network_25_vector(canvas, bounds, paint);
_network_26_vector(canvas, bounds, paint);
_network_27_vector(canvas, bounds, paint);
_network_28_vector(canvas, bounds, paint);
_network_29_vector(canvas, bounds, paint);
_network_30_vector(canvas, bounds, paint);
_network_31_vector(canvas, bounds, paint);
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_1_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 6.882365, 0.000000, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(443.951508, 222.100634);
path.cubicTo(443.951508, 255.790592, 436.456510, 287.734282, 423.030935, 316.346150);
path.cubicTo(422.342095, 317.824564, 421.627134, 319.296446, 420.904991, 320.761795);
path.cubicTo(418.022950, 326.561780, 414.894107, 332.221304, 411.537385, 337.720122);
path.cubicTo(411.049647, 338.523029, 410.561253, 339.318746, 410.059802, 340.108582);
path.cubicTo(410.059802, 340.108582, 33.891706, 340.108582, 33.891706, 340.108582);
path.cubicTo(33.770916, 339.914551, 33.650776, 339.727056, 33.530635, 339.533025);
path.cubicTo(33.530635, 339.533025, 33.370016, 339.272359, 33.370016, 339.272359);
path.cubicTo(33.048773, 338.756905, 32.728185, 338.242105, 32.414122, 337.720122);
path.cubicTo(29.164484, 332.401614, 26.129006, 326.929593, 23.327277, 321.323632);
path.cubicTo(22.585544, 319.845218, 21.863407, 318.353083, 21.154322, 316.847883);
path.cubicTo(7.956620, 288.884744, 0.414614, 257.723703, 0.020239, 224.843182);
path.cubicTo(0.006526, 223.933787, 0.000000, 223.017214, 0.000000, 222.100634);
path.cubicTo(0.000000, 210.199493, 0.936303, 198.519165, 2.741006, 187.133477);
path.cubicTo(19.496532, 81.080242, 111.275167, 0.000000, 221.975754, 0.000000);
path.cubicTo(333.993303, 0.000000, 426.634463, 83.019885, 441.778552, 190.926529);
path.cubicTo(443.209126, 201.114720, 443.951508, 211.517198, 443.951508, 222.100634);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.901961, green: 0.901961, blue: 0.901961, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_2_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 6.882372, 181.863617, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(72.964421, 42.458227);
path.cubicTo(64.459988, 41.086301, 26.236083, 42.417716, 0.020238, 42.979557);
path.cubicTo(0.006525, 42.070162, 0.000000, 41.153592, 0.000000, 40.237012);
path.cubicTo(0.000000, 28.335871, 0.936303, 16.655543, 2.741006, 5.269856);
path.cubicTo(3.497100, 4.627009, 4.345911, 3.992001, 5.295272, 3.356345);
path.cubicTo(6.030473, 2.867676, 10.691094, 0.238801, 11.011681, 0.178700);
path.cubicTo(15.772205, -0.724815, 23.320746, 1.924966, 26.898153, 5.262670);
path.cubicTo(33.637056, 11.551322, 30.421369, 20.549209, 35.155122, 24.335723);
path.cubicTo(44.689228, 9.216431, 53.133590, 23.479248, 64.386209, 32.603871);
path.cubicTo(66.224864, 34.088821, 73.927494, 34.048969, 72.964421, 42.458227);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 1.000000, green: 1.000000, blue: 1.000000, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_3_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 17.577431, 240.828918, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(86.673317, 1.307720);
path.cubicTo(79.739837, 8.458725, 74.371442, 17.115586, 71.048018, 26.508061);
path.cubicTo(70.854096, 27.036580, 70.673891, 27.571628, 70.500208, 28.106683);
path.cubicTo(63.299027, 50.156165, 67.390947, 74.788136, 60.992222, 96.891188);
path.cubicTo(60.758472, 97.694095, 60.511013, 98.489813, 60.250492, 99.279648);
path.cubicTo(60.250492, 99.279648, 28.184382, 99.279648, 28.184382, 99.279648);
path.cubicTo(28.184382, 99.279648, 22.835569, 98.704092, 22.835569, 98.704092);
path.cubicTo(22.835569, 98.704092, 22.614876, 98.677306, 22.614876, 98.677306);
path.cubicTo(22.634466, 98.596949, 22.654704, 98.523128, 22.674943, 98.443426);
path.cubicTo(22.808797, 97.927972, 22.949176, 97.413171, 23.075843, 96.891188);
path.cubicTo(24.961507, 89.499117, 26.492630, 81.718976, 25.944170, 74.279869);
path.cubicTo(25.810316, 72.426460, 25.549803, 70.600492, 25.122132, 68.800654);
path.cubicTo(24.687280, 66.907393, 24.078746, 65.054636, 23.263239, 63.248269);
path.cubicTo(20.421682, 56.932831, 15.393457, 51.915498, 11.355732, 46.289943);
path.cubicTo(5.425155, 38.034209, 1.587227, 28.280459, 0.297033, 18.192876);
path.cubicTo(-0.365036, 13.061215, -0.158057, 7.268416, 3.419350, 3.528282);
path.cubicTo(5.972967, 0.852371, 9.884675, -0.237983, 13.568516, 0.042934);
path.cubicTo(17.252357, 0.324506, 20.749451, 1.842774, 23.925309, 3.742564);
path.cubicTo(31.800968, 8.458723, 38.139626, 15.710990, 41.750336, 24.160106);
path.cubicTo(45.360391, 32.609215, 46.236627, 42.202255, 44.196870, 51.166818);
path.cubicTo(46.650585, 39.566194, 50.047133, 27.879330, 56.940783, 18.239260);
path.cubicTo(63.840960, 8.592654, 74.819344, 1.233898, 86.673317, 1.307720);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 1.000000, green: 1.000000, blue: 1.000000, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_4_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 343.185516, 172.458084, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(96.048350, 165.262053);
path.cubicTo(96.048350, 165.262053, 100.454331, 165.262053, 100.454331, 165.262053);
path.cubicTo(100.193162, 166.057768, 99.926108, 166.860677, 99.645349, 167.650513);
path.cubicTo(99.645349, 167.650513, 67.559039, 167.650513, 67.559039, 167.650513);
path.cubicTo(67.559039, 167.650513, 57.416403, 166.552971, 57.416403, 166.552971);
path.cubicTo(57.416403, 166.552971, 45.474942, 165.262053, 45.474942, 165.262053);
path.cubicTo(45.474942, 165.262053, 37.686127, 164.419298, 37.686127, 164.419298);
path.cubicTo(42.794010, 144.992155, 47.006065, 123.705070, 38.769340, 105.388537);
path.cubicTo(38.153625, 104.017267, 37.471966, 102.679311, 36.736765, 101.374670);
path.cubicTo(36.736765, 101.374670, 36.729583, 101.360951, 36.729583, 101.360951);
path.cubicTo(31.869163, 92.664239, 24.775066, 85.272171, 18.918269, 77.130757);
path.cubicTo(9.042682, 63.369675, 2.644611, 47.120823, 0.491894, 30.308842);
path.cubicTo(-0.605027, 21.759774, -0.264203, 12.105983, 5.693145, 5.871552);
path.cubicTo(9.952218, 1.422588, 16.471088, -0.396852, 22.608637, 0.071566);
path.cubicTo(28.753374, 0.539329, 34.576866, 3.061716, 39.865612, 6.225640);
path.cubicTo(52.996715, 14.086129, 63.553958, 26.174768, 69.571373, 40.250088);
path.cubicTo(75.348506, 53.763573, 76.912936, 69.036388, 74.038076, 83.432476);
path.cubicTo(78.096047, 64.707632, 83.752388, 45.942928, 94.884867, 30.382665);
path.cubicTo(97.960174, 26.081345, 101.523877, 22.053756, 105.475413, 18.468456);
path.cubicTo(106.905987, 28.656647, 107.648369, 39.059126, 107.648369, 49.642563);
path.cubicTo(107.648369, 83.332521, 100.153371, 115.276212, 86.727796, 143.888081);
path.cubicTo(86.727796, 143.888081, 96.048391, 148.477504, 96.048391, 148.477504);
path.cubicTo(96.048391, 148.477504, 96.048350, 165.262053, 96.048350, 165.262053);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 1.000000, green: 1.000000, blue: 1.000000, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_5_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 394.122894, 301.227509, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(45.110985, 19.708060);
path.cubicTo(45.110985, 19.708060, 45.110985, 36.552711, 45.110985, 36.552711);
path.cubicTo(45.110985, 36.552711, 40.029261, 36.552711, 40.029261, 36.552711);
path.cubicTo(40.029261, 36.552711, 40.022732, 36.492608, 40.022732, 36.492608);
path.cubicTo(40.022732, 36.492608, 38.124007, 21.614385, 38.124007, 21.614385);
path.cubicTo(38.124007, 21.614385, 33.664486, 19.534282, 33.664486, 19.534282);
path.cubicTo(33.664486, 19.534282, 10.457348, 8.696711, 10.457348, 8.696711);
path.cubicTo(10.457348, 8.696711, 0.000000, 3.813304, 0.000000, 3.813304);
path.cubicTo(0.000000, 3.813304, 0.000000, 0.000000, 0.000000, 0.000000);
path.cubicTo(0.000000, 0.000000, 6.358857, 0.635660, 6.358857, 0.635660);
path.cubicTo(6.358857, 0.635660, 13.372034, 4.087036, 13.372034, 4.087036);
path.cubicTo(13.372034, 4.087036, 35.790390, 15.118637, 35.790390, 15.118637);
path.cubicTo(35.790390, 15.118637, 45.110985, 19.708060, 45.110985, 19.708060);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.035294, green: 0.031373, blue: 0.078431, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_6_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 142.140350, 116.509277, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(203.970535, 223.137407);
path.cubicTo(203.970535, 223.137407, 174.331351, 223.599289, 174.331351, 223.599289);
path.cubicTo(174.331351, 223.599289, 0.000000, 223.599289, 0.000000, 223.599289);
path.cubicTo(0.000000, 223.599289, 0.080311, 221.210829, 0.080311, 221.210829);
path.cubicTo(0.080311, 221.210829, 0.227220, 216.802370, 0.227220, 216.802370);
path.cubicTo(0.227220, 216.802370, 88.543361, 0.000000, 88.543361, 0.000000);
path.cubicTo(88.543361, 0.000000, 202.974162, 221.210829, 202.974162, 221.210829);
path.cubicTo(202.974162, 221.210829, 203.642764, 222.501747, 203.642764, 222.501747);
path.cubicTo(203.642764, 222.501747, 203.970535, 223.137407, 203.970535, 223.137407);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = styles.accent.dark.withValues(alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_7_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 72.307098, 108.276192, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(37.856434, 0.179486);
path.cubicTo(42.614310, -0.726584, 50.161020, 1.925374, 53.740580, 5.265273);
path.cubicTo(60.477089, 11.550761, 57.262500, 20.545535, 62.000345, 24.336980);
path.cubicTo(71.529845, 9.215232, 79.975118, 23.476999, 91.227169, 32.601381);
path.cubicTo(93.064085, 34.090948, 100.772871, 34.046733, 99.804615, 42.455095);
path.cubicTo(86.953034, 40.382127, 6.239855, 44.487757, 1.640571, 42.772966);
path.cubicTo(-2.792546, 41.120122, 1.862350, 31.524284, 14.347886, 35.780006);
path.cubicTo(25.943719, 21.951913, 18.696374, 12.302050, 32.138143, 3.358110);
path.cubicTo(32.872535, 2.869462, 37.535124, 0.240671, 37.856434, 0.179486);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 1.000000, green: 1.000000, blue: 1.000000, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_8_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 296.288666, 81.106194, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(48.181613, 0.228440);
path.cubicTo(54.237185, -0.924758, 63.842256, 2.450519, 68.398121, 6.701358);
path.cubicTo(76.971988, 14.701189, 72.880605, 26.149242, 78.910683, 30.974793);
path.cubicTo(91.039318, 11.728643, 101.788036, 29.880262, 116.109042, 41.493289);
path.cubicTo(118.446969, 43.389132, 128.258265, 43.332856, 127.025932, 54.034561);
path.cubicTo(110.669134, 51.396200, 7.941757, 56.621610, 2.088029, 54.439116);
path.cubicTo(-3.554200, 52.335462, 2.370296, 40.122403, 18.261220, 45.538861);
path.cubicTo(33.019780, 27.939213, 23.795735, 15.657372, 40.903694, 4.274012);
path.cubicTo(41.838385, 3.652090, 47.772669, 0.306315, 48.181613, 0.228440);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 1.000000, green: 1.000000, blue: 1.000000, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_9_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 54.052090, 116.509277, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(176.631638, 0.000000);
path.cubicTo(176.631638, 0.000000, 125.583507, 221.210829, 125.583507, 221.210829);
path.cubicTo(125.583507, 221.210829, 125.035045, 223.599289, 125.035045, 223.599289);
path.cubicTo(125.035045, 223.599289, 8.838726, 223.599289, 8.838726, 223.599289);
path.cubicTo(8.838726, 223.599289, 8.658517, 221.210829, 8.658517, 221.210829);
path.cubicTo(8.658517, 221.210829, 6.351716, 190.712237, 6.351716, 190.712237);
path.cubicTo(6.351716, 190.712237, 0.000000, 187.534592, 0.000000, 187.534592);
path.cubicTo(0.000000, 187.534592, 34.573362, 150.827703, 34.573362, 150.827703);
path.cubicTo(34.573362, 150.827703, 176.631638, 0.000000, 176.631638, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = styles.accent.medium.withValues(alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_10_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 230.684723, 116.507332, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(171.548806, 222.503189);
path.cubicTo(171.548806, 222.503189, 67.666475, 222.503189, 67.666475, 222.503189);
path.cubicTo(67.666475, 222.503189, 0.000000, 0.000000, 0.000000, 0.000000);
path.cubicTo(0.000000, 0.000000, 177.902481, 187.538400, 177.902481, 187.538400);
path.cubicTo(177.902481, 187.538400, 174.005542, 192.089891, 174.005542, 192.089891);
path.cubicTo(174.005542, 192.089891, 171.548806, 222.503189, 171.548806, 222.503189);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = styles.accent.medium.withValues(alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_11_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 201.791092, 75.185310, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(6.338127, 0.000000);
path.cubicTo(6.338127, 0.000000, 0.000000, 3.373956, 0.000000, 3.373956);
path.cubicTo(0.000000, 3.373956, 28.893619, 41.322018, 28.893619, 41.322018);
path.cubicTo(28.893619, 41.322018, 59.494205, 2.081624, 59.494205, 2.081624);
path.cubicTo(59.494205, 2.081624, 55.261313, 0.000000, 55.261313, 0.000000);
path.cubicTo(55.261313, 0.000000, 31.117402, 30.514723, 31.117402, 30.514723);
path.cubicTo(31.117402, 30.514723, 6.338127, 0.000000, 6.338127, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.035294, green: 0.031373, blue: 0.078431, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_12_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 15.295661, 303.410004, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(45.110985, 0.000000);
path.cubicTo(45.110985, 0.000000, 38.757330, 0.635721, 38.757330, 0.635721);
path.cubicTo(38.757330, 0.635721, 0.000000, 19.707407, 0.000000, 19.707407);
path.cubicTo(0.000000, 19.707407, 0.000000, 36.554081, 0.000000, 36.554081);
path.cubicTo(0.000000, 36.554081, 5.082930, 36.554081, 5.082930, 36.554081);
path.cubicTo(5.082930, 36.554081, 6.989028, 21.614590, 6.989028, 21.614590);
path.cubicTo(6.989028, 21.614590, 45.110985, 3.814325, 45.110985, 3.814325);
path.cubicTo(45.110985, 3.814325, 45.110985, 0.000000, 45.110985, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.035294, green: 0.031373, blue: 0.078431, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_13_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 248.210144, 177.218918, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(1.535556, 0.000000);
path.cubicTo(1.535556, 0.000000, 33.701136, 105.019686, 75.873383, 136.998396);
path.cubicTo(75.873383, 136.998396, 75.873383, 161.473740, 75.873383, 161.473740);
path.cubicTo(75.873383, 161.473740, 47.281906, 161.473740, 47.281906, 161.473740);
path.cubicTo(47.281906, 161.473740, -10.004048, 41.081934, 1.535556, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = styles.accent.light.withValues(alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_14_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, -0.000002, 337.720123, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(452.953280, 2.388460);
path.cubicTo(452.953280, 2.388460, 1.032103, 2.388460, 1.032103, 2.388460);
path.cubicTo(0.417043, 2.341424, -0.037399, 1.806369, 0.002429, 1.190963);
path.cubicTo(-0.037399, 0.582087, 0.417043, 0.047036, 1.032103, 0.000000);
path.cubicTo(1.032103, 0.000000, 452.953280, 0.000000, 452.953280, 0.000000);
path.cubicTo(453.495215, 0.066637, 453.922889, 0.495201, 453.989482, 1.036785);
path.cubicTo(454.076320, 1.699227, 453.615349, 2.300917, 452.953280, 2.388460);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.800000, green: 0.800000, blue: 0.800000, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_15_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 66.206619, 134.927612, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(39.771339, 0.000000);
path.cubicTo(39.771339, 0.000000, 15.760937, 2.336329, 15.760937, 2.336329);
path.cubicTo(11.503121, 2.750633, 7.890927, 5.818619, 7.021799, 10.009657);
path.cubicTo(6.503425, 12.509300, 7.069882, 14.796450, 10.608009, 15.191428);
path.cubicTo(10.608009, 15.191428, 0.552703, 18.284610, 4.552606, 25.145178);
path.cubicTo(4.552606, 25.145178, 0.245570, 49.770319, 0.245570, 49.770319);
path.cubicTo(-1.384842, 59.092056, 5.290476, 67.855211, 14.712798, 68.677312);
path.cubicTo(14.841611, 68.688550, 14.970466, 68.698819, 15.099339, 68.708057);
path.cubicTo(21.281791, 69.151188, 32.057589, 64.051047, 33.282488, 57.971564);
path.cubicTo(33.282488, 57.971564, 34.591901, 25.988688, 34.591901, 25.988688);
path.cubicTo(34.591901, 25.988688, 39.771339, 0.000000, 39.771339, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.035294, green: 0.031373, blue: 0.078431, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_16_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 65.148689, 160.759979, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(7.153327, 0.156319);
path.cubicTo(4.954135, -0.445681, 2.661200, 0.739117, 1.885181, 2.884208);
path.cubicTo(0.475628, 6.780502, -1.092849, 12.695001, 1.057922, 15.513646);
path.cubicTo(1.057922, 15.513646, 3.416992, 16.782673, 4.529211, 13.158177);
path.cubicTo(5.641430, 9.533682, 7.153327, 0.156319, 7.153327, 0.156319);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.035294, green: 0.031373, blue: 0.078431, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_17_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 70.735252, 159.580200, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(22.671540, 3.568074);
path.cubicTo(15.989341, -0.386462, 0.204532, 0.784744, 0.047705, 0.796679);
path.cubicTo(0.047705, 0.796679, 0.000000, 0.188100, 0.000000, 0.188100);
path.cubicTo(0.656533, 0.135599, 16.136628, -1.008157, 22.982815, 3.041841);
path.cubicTo(22.982815, 3.041841, 22.671540, 3.568074, 22.671540, 3.568074);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 1.000000, green: 1.000000, blue: 1.000000, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_18_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 130.662170, 179.865585, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(15.939054, 26.927989);
path.cubicTo(15.939054, 26.927989, 0.000000, 2.471980, 0.000000, 2.471980);
path.cubicTo(0.000000, 2.471980, 9.621280, 0.000000, 9.621280, 0.000000);
path.cubicTo(9.621280, 0.000000, 21.843308, 23.287421, 21.843308, 23.287421);
path.cubicTo(23.566816, 23.668792, 25.247648, 24.846748, 26.357828, 26.649255);
path.cubicTo(28.300343, 29.803184, 27.760316, 33.663858, 25.151640, 35.272368);
path.cubicTo(22.542956, 36.880865, 18.853525, 35.628083, 16.911003, 32.474147);
path.cubicTo(15.800824, 30.671627, 15.504824, 28.639816, 15.939054, 26.927989);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 1.000000, green: 0.713726, blue: 0.713726, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_19_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 81.769371, 173.345108, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(1.963927, 29.162599);
path.cubicTo(1.963927, 29.162599, 0.558181, 0.000000, 0.558181, 0.000000);
path.cubicTo(0.558181, 0.000000, 10.109382, 2.730564, 10.109382, 2.730564);
path.cubicTo(10.109382, 2.730564, 8.897491, 29.005644, 8.897491, 29.005644);
path.cubicTo(10.192258, 30.206037, 11.047960, 32.072312, 11.095819, 34.189058);
path.cubicTo(11.179554, 37.892820, 8.764046, 40.951480, 5.700586, 41.020827);
path.cubicTo(2.637127, 41.090160, 0.085850, 38.143918, 0.002108, 34.440149);
path.cubicTo(-0.045751, 32.323390, 0.724794, 30.420351, 1.963927, 29.162599);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 1.000000, green: 0.713726, blue: 0.713726, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_20_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[-1.000000, -0.000000, 0, 0, 0.000000, -1.000000, 0, 0, 0, 0, 1, 0, 137.969864, 329.921539, 0, 1]));
{
final path = ui.Path();
{
path.moveTo(0.000000, 0.000000);
path.cubicTo(0.000000, 0.000000, 12.172180, 0.000000, 12.172180, 0.000000);
path.cubicTo(12.172180, 0.000000, 12.172180, 16.052200, 12.172180, 16.052200);
path.cubicTo(12.172180, 16.052200, 0.000000, 16.052200, 0.000000, 16.052200);
path.cubicTo(0.000000, 16.052200, 0.000000, 0.000000, 0.000000, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 1.000000, green: 0.721569, blue: 0.721569, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_21_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 121.656143, 320.316620, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(1.677081, 19.109986);
path.cubicTo(0.635934, 18.266679, 0.073918, 17.325013, 0.006750, 16.311030);
path.cubicTo(-0.070119, 15.151229, 0.509891, 13.906853, 1.730376, 12.612461);
path.cubicTo(1.759674, 12.239988, 2.138473, 7.625268, 2.982576, 6.798920);
path.cubicTo(2.911818, 6.551900, 2.481845, 4.914263, 3.186658, 3.850889);
path.cubicTo(3.518686, 3.349985, 4.053875, 3.058010, 4.777382, 2.983084);
path.cubicTo(4.777382, 2.983084, 4.808907, 2.979879, 4.808907, 2.979879);
path.cubicTo(4.808907, 2.979879, 4.824526, 3.007440, 4.824526, 3.007440);
path.cubicTo(4.844925, 3.043478, 6.898919, 6.613285, 9.988621, 6.926701);
path.cubicTo(11.760001, 7.106375, 13.533503, 6.194490, 15.259919, 4.215634);
path.cubicTo(15.321972, 4.069442, 15.809770, 1.659197, 16.124615, 0.063799);
path.cubicTo(16.124615, 0.063799, 16.137204, 0.000000, 16.137204, 0.000000);
path.cubicTo(16.137204, 0.000000, 32.972099, 8.853830, 32.972099, 8.853830);
path.cubicTo(32.972099, 8.853830, 42.812733, 11.578351, 42.812733, 11.578351);
path.cubicTo(44.049552, 11.920794, 44.913345, 13.056720, 44.913345, 14.340742);
path.cubicTo(44.913345, 15.435611, 44.276079, 16.449587, 43.289832, 16.923926);
path.cubicTo(43.289832, 16.923926, 38.519883, 19.218106, 38.519883, 19.218106);
path.cubicTo(36.526781, 20.176732, 34.304383, 20.683414, 32.092916, 20.683414);
path.cubicTo(32.092916, 20.683414, 6.219096, 20.683414, 6.219096, 20.683414);
path.cubicTo(4.542757, 20.683414, 2.929706, 20.124631, 1.677081, 19.109986);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.035294, green: 0.031373, blue: 0.078431, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_22_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[-0.923839, -0.382782, 0, 0, 0.382414, -0.923991, 0, 0, 0, 0, 1, 0, 97.796234, 318.216278, 0, 1]));
{
final path = ui.Path();
{
path.moveTo(0.000000, 0.000000);
path.cubicTo(0.000000, 0.000000, 12.173173, 0.000000, 12.173173, 0.000000);
path.cubicTo(12.173173, 0.000000, 12.173173, 16.050880, 12.173173, 16.050880);
path.cubicTo(12.173173, 16.050880, 0.000000, 16.050880, 0.000000, 16.050880);
path.cubicTo(0.000000, 16.050880, 0.000000, 0.000000, 0.000000, 0.000000);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 1.000000, green: 0.721569, blue: 0.721569, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_23_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 80.001442, 307.563202, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(0.637209, 13.831872);
path.cubicTo(-0.002262, 12.654163, -0.161434, 11.569001, 0.164242, 10.606456);
path.cubicTo(0.536713, 9.505472, 1.548415, 8.577798, 3.170991, 7.849107);
path.cubicTo(3.340488, 7.516190, 5.455045, 3.397609, 6.550910, 2.957268);
path.cubicTo(6.579987, 2.701953, 6.808948, 1.024309, 7.866750, 0.311653);
path.cubicTo(8.365052, -0.024033, 8.971158, -0.088916, 9.668269, 0.118828);
path.cubicTo(9.668269, 0.118828, 9.698620, 0.127934, 9.698620, 0.127934);
path.cubicTo(9.698620, 0.127934, 9.702507, 0.159374, 9.702507, 0.159374);
path.cubicTo(9.707575, 0.200482, 10.240265, 4.284959, 12.975040, 5.757306);
path.cubicTo(14.542937, 6.601422, 16.530186, 6.437855, 18.881925, 5.270455);
path.cubicTo(18.995160, 5.159138, 20.367483, 3.119011, 21.268430, 1.765529);
path.cubicTo(21.268430, 1.765529, 21.304454, 1.711407, 21.304454, 1.711407);
path.cubicTo(21.304454, 1.711407, 33.472911, 16.336211, 33.472911, 16.336211);
path.cubicTo(33.472911, 16.336211, 41.523014, 22.620557, 41.523014, 22.620557);
path.cubicTo(42.534782, 23.410419, 42.898499, 24.790594, 42.407511, 25.976919);
path.cubicTo(41.988853, 26.988487, 41.012340, 27.681354, 39.919751, 27.742051);
path.cubicTo(39.919751, 27.742051, 34.635476, 28.035668, 34.635476, 28.035668);
path.cubicTo(32.427459, 28.158365, 30.180404, 27.775741, 28.137197, 26.929163);
path.cubicTo(28.137197, 26.929163, 4.231984, 17.024318, 4.231984, 17.024318);
path.cubicTo(2.683188, 16.382594, 1.406549, 15.248841, 0.637209, 13.831872);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.035294, green: 0.031373, blue: 0.078431, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_24_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 96.555237, 189.716110, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(43.625158, 127.666252);
path.cubicTo(43.625158, 127.666252, 28.487942, 127.238444, 28.487942, 127.238444);
path.cubicTo(28.487942, 127.238444, 20.879682, 91.729356, 20.879682, 91.729356);
path.cubicTo(20.879682, 91.729356, 20.049622, 87.855968, 20.049622, 87.855968);
path.cubicTo(20.049622, 87.855968, 16.733566, 74.757309, 11.116369, 58.969593);
path.cubicTo(9.107415, 53.300314, 6.799114, 47.288561, 4.240369, 41.411049);
path.cubicTo(-5.437667, 19.147395, 4.478893, 2.596576, 4.478893, 2.596576);
path.cubicTo(4.478893, 2.596576, 28.225566, 0.501182, 28.225566, 0.501182);
path.cubicTo(28.225566, 0.501182, 33.892265, 0.000000, 33.892265, 0.000000);
path.cubicTo(33.892265, 0.000000, 38.251857, 57.155220, 38.251857, 57.155220);
path.cubicTo(38.251857, 57.155220, 43.625158, 127.666252, 43.625158, 127.666252);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.035294, green: 0.031373, blue: 0.078431, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_25_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 90.787811, 189.716110, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(44.019273, 57.155218);
path.cubicTo(44.019273, 57.155218, 26.647097, 91.729353, 26.647097, 91.729353);
path.cubicTo(26.647097, 91.729353, 12.743638, 119.393814, 12.743638, 119.393814);
path.cubicTo(12.743638, 119.393814, 0.000000, 111.206696, 0.000000, 111.206696);
path.cubicTo(0.000000, 111.206696, 13.079367, 73.113568, 13.079367, 73.113568);
path.cubicTo(13.079367, 73.113568, 14.777044, 67.498577, 16.883794, 58.969592);
path.cubicTo(19.130670, 49.909599, 21.841475, 37.561527, 23.478339, 25.165716);
path.cubicTo(24.980433, 13.807464, 29.571988, 5.798155, 33.993002, 0.501182);
path.cubicTo(33.993002, 0.501182, 39.659691, 0.000000, 39.659691, 0.000000);
path.cubicTo(39.659691, 0.000000, 44.019273, 57.155218, 44.019273, 57.155218);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.035294, green: 0.031373, blue: 0.078431, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_26_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 96.555237, 133.457336, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(27.837501, 1.298319);
path.cubicTo(27.837501, 1.298319, 14.429129, 0.000000, 14.429129, 0.000000);
path.cubicTo(14.429129, 0.000000, 0.000000, 30.280993, 0.000000, 30.280993);
path.cubicTo(0.000000, 30.280993, 4.478894, 58.855366, 4.478894, 58.855366);
path.cubicTo(4.478894, 58.855366, 33.892255, 56.258769, 33.892255, 56.258769);
path.cubicTo(33.892255, 56.258769, 35.385200, 43.028066, 38.468630, 34.882338);
path.cubicTo(39.557796, 32.005005, 39.481888, 28.818634, 38.283045, 25.985299);
path.cubicTo(38.283045, 25.985299, 27.837501, 1.298319, 27.837501, 1.298319);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.839216, green: 0.839216, blue: 0.890196, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_27_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 78.422829, 133.421143, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(34.724178, 3.281988);
path.cubicTo(34.724178, 3.281988, 32.561537, 0.036196, 32.561537, 0.036196);
path.cubicTo(32.561537, 0.036196, 26.432868, -0.953735, 22.375686, 7.420329);
path.cubicTo(18.318504, 15.794392, 0.000000, 39.621847, 0.000000, 39.621847);
path.cubicTo(0.000000, 39.621847, 17.097267, 52.452000, 17.097267, 52.452000);
path.cubicTo(17.097267, 52.452000, 34.724178, 3.281988, 34.724178, 3.281988);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.839216, green: 0.839216, blue: 0.890196, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_28_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 123.095154, 134.737549, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(0.000010, 0.883640);
path.cubicTo(0.000010, 0.883640, 1.297589, 0.018101, 1.297589, 0.018101);
path.cubicTo(1.297589, 0.018101, 6.254651, -0.316121, 7.352996, 1.887760);
path.cubicTo(8.451342, 4.091640, 23.106138, 42.582151, 23.106138, 42.582151);
path.cubicTo(23.106138, 42.582151, 3.566403, 52.357517, 3.566403, 52.357517);
path.cubicTo(3.566403, 52.357517, 0.000010, 0.883640, 0.000010, 0.883640);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.839216, green: 0.839216, blue: 0.890196, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_29_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 108.528023, 103.664246, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(0.000000, 12.301705);
path.cubicTo(0.000000, 5.507667, 5.504568, 0.000000, 12.294840, 0.000000);
path.cubicTo(19.085105, 0.000000, 24.589680, 5.507660, 24.589680, 12.301705);
path.cubicTo(24.589680, 17.811674, 20.968909, 22.474960, 15.978372, 24.041104);
path.cubicTo(15.978372, 24.041104, 13.601570, 39.757744, 13.601570, 39.757744);
path.cubicTo(13.601570, 39.757744, 1.484878, 29.654858, 1.484878, 29.654858);
path.cubicTo(1.484878, 29.654858, 4.102475, 26.318895, 5.506231, 22.557320);
path.cubicTo(2.188456, 20.354262, 0.000000, 16.584414, 0.000000, 12.301705);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 1.000000, green: 0.713726, blue: 0.713726, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_30_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 104.440765, 101.684616, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(0.139713, 30.444441);
path.cubicTo(0.139713, 30.444441, 0.713847, 34.802782, 6.033102, 34.945107);
path.cubicTo(13.226524, 35.137581, 16.823230, 35.233814, 16.823230, 35.233814);
path.cubicTo(16.823230, 35.233814, 7.701850, 13.023291, 11.452432, 15.525469);
path.cubicTo(15.203013, 18.027646, 25.204571, 7.537760, 25.204571, 7.537760);
path.cubicTo(25.204571, 7.537760, 28.155678, 13.075660, 28.155678, 13.075660);
path.cubicTo(28.155678, 13.075660, 35.206115, 10.521121, 27.392401, 4.265683);
path.cubicTo(27.392401, 4.265683, 18.069516, -2.946103, 8.172146, 1.384585);
path.cubicTo(-1.725225, 5.715273, 0.139713, 30.444441, 0.139713, 30.444441);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.035294, green: 0.031373, blue: 0.078431, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@pragma('vm:prefer-inline')
void _network_31_vector(ui.Canvas canvas, fl.Rect bounds, ui.Paint paint) {
canvas.save();
canvas.transform(Float64List.fromList(const <double>[1.000000, 0.000000, 0, 0, 0.000000, 1.000000, 0, 0, 0, 0, 1, 0, 97.657257, 133.025070, 0, 1]));
{
final path = ui.Path();
path.fillType = ui.PathFillType.nonZero;
{
path.moveTo(3.663710, 3.665761);
path.cubicTo(3.663710, 3.665761, 22.040850, 16.165415, 0.000000, 47.043932);
path.cubicTo(0.000000, 47.043932, 1.753549, 61.075500, 1.753549, 61.075500);
path.cubicTo(1.753549, 61.075500, 28.592534, 19.982989, 10.380486, 0.000000);
path.cubicTo(10.380486, 0.000000, 3.663710, 3.665761, 3.663710, 3.665761);
path.close();
}
paint.style = ui.PaintingStyle.fill;
paint
..blendMode = ui.BlendMode.srcOver
..color = const ui.Color.from(red: 0.035294, green: 0.031373, blue: 0.078431, alpha: 1.000000)
;
canvas.drawPath(path, paint);
}
canvas.restore();
}
@override
bool shouldRepaint(covariant CampPainter oldDelegate) => false;
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment