1
00:00:00,000 --> 00:00:13,000

2
00:00:13,000 --> 00:00:15,890
>> ರಾಬ್ BOWDEN: ನಾನು ರಾಬ್ ಮನುಷ್ಯ, ಮತ್ತು
ತಂದೆಯ ಬಿರುಕುಗಳು ತಿಳಿದುಕೊಳ್ಳೋಣ.

3
00:00:15,890 --> 00:00:19,390
ಆದ್ದರಿಂದ pset ವಿಶೇಷ ರಿಂದ ಮರೆಯದಿರಿ ಎಂದು
ನಾವು ಬಳಸಲು ಬಯಸುವ ಎಂದು ನೀನು

4
00:00:19,390 --> 00:00:20,890
ಸಂಯೋಜಿತಗೊಂಡಿದೆ ಕಾರ್ಯ.

5
00:00:20,890 --> 00:00:26,330
ಮನುಷ್ಯ ಪುಟ ಫಾರ್, ನಾವು ಎರಡು
ಹ್ಯಾಶ್ _xopensource ವ್ಯಾಖ್ಯಾನಿಸಲು.

6
00:00:26,330 --> 00:00:28,290
ಏಕೆ ಬಗ್ಗೆ ಚಿಂತಿಸಬೇಡಿ
ನಾವು ಮಾಡಬೇಕಾದ್ದು.

7
00:00:28,290 --> 00:00:31,550
ಮತ್ತು ಹ್ಯಾಶ್ unistd.h ಸೇರಿವೆ.

8
00:00:31,550 --> 00:00:35,920
>> ಆದ್ದರಿಂದ ಒಮ್ಮೆ ಆ ರೀತಿಯಲ್ಲಿ ಹೊರಗೆ ಇಲ್ಲಿದೆ, ನಾವು
ನಿಜವಾದ ಕಾರ್ಯಕ್ರಮಕ್ಕೆ ಪಡೆಯಿರಿ.

9
00:00:35,920 --> 00:00:39,570
ನಾವು ಮಾಡಬೇಕಾದ್ದು ಮೊದಲ ವಿಷಯ ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಿ ಆಗಿದೆ
ಬಳಕೆದಾರ ಮಾನ್ಯ ಎನ್ಕ್ರಿಪ್ಟ್ ನಮೂದಿಸಿದ

10
00:00:39,570 --> 00:00:41,520
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ನಲ್ಲಿ ಪಾಸ್ವರ್ಡ್.

11
00:00:41,520 --> 00:00:46,050
ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಹೇಳಲಾಗುವ ನೆನಪಿಡಿ
ಡಾಟ್ ಕಡಿದು ಬಿರುಕು ರೀತಿಯ ಔಟ್, ಮತ್ತು ಮಾಡಬೇಕು

12
00:00:46,050 --> 00:00:48,120
ನಂತರ ಎನ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ರಿಂಗ್.

13
00:00:48,120 --> 00:00:52,990
>> ಆದ್ದರಿಂದ ಇಲ್ಲಿ ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಲು ತಪಾಸಣೆ ನೀವು
ಆ ಎರಡು argc ನಾವು ಬಯಸಿದರೆ

14
00:00:52,990 --> 00:00:54,380
ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ಮುಂದುವರೆಯಲು.

15
00:00:54,380 --> 00:00:58,830
Argc ಎರಡು ಇದ್ದರೆ, ಆ ಎರಡೂ ಅರ್ಥ
ಬಳಕೆದಾರ ಒಂದು ಎನ್ಕ್ರಿಪ್ಟ್ ಪಡೆಯಲಿಲ್ಲ

16
00:00:58,830 --> 00:01:02,560
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ನಲ್ಲಿ ಪಾಸ್ವರ್ಡ್, ಅಥವಾ ಅವರು
ಕೇವಲ ಎನ್ಕ್ರಿಪ್ಟ್ ಹೆಚ್ಚು ನಮೂದಿಸಿದ

17
00:01:02,560 --> 00:01:05,379
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ನಲ್ಲಿ ಪಾಸ್ವರ್ಡ್, ಇದರಲ್ಲಿ
ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಏನು ಮಾಡಬೇಕೆಂದು ಗೊತ್ತಿಲ್ಲ

18
00:01:05,379 --> 00:01:07,660
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ವಾದಗಳು.

19
00:01:07,660 --> 00:01:11,390
>> Argc ಎರಡು ಆದ್ದರಿಂದ, ನಾವು ಮುಂದುವರಿಸಬಹುದು.

20
00:01:11,390 --> 00:01:14,160
ಇಲ್ಲಿ, ನಾವು ಘೋಷಿಸಲು ಹೊರಟಿರುವೆ
ಒಂದು ವೇರಿಯಬಲ್ ಎನ್ಕ್ರಿಪ್ಟ್.

21
00:01:14,160 --> 00:01:17,650
ಅದು ಕೇವಲ ಅಲಿಯಾಸ್ ಮೂಲ ಹೋಗುತ್ತೇನೆಂದು
argv1 ಆದ್ದರಿಂದ ಈ ಪೂರ್ತಿ

22
00:01:17,650 --> 00:01:20,690
ಕಾರ್ಯಕ್ರಮ, ನಾವು, ಇದು argv1 ಕರೆಯಲು ಹೊಂದಿಲ್ಲ
ನಂತರ ನೀವು ಆಲೋಚಿಸುತ್ತೀರಿ ಮಾಡಬೇಕು

23
00:01:20,690 --> 00:01:22,950
ಎಂದು ವಾಸ್ತವವಾಗಿ ಅರ್ಥ ಏನು ಬಗ್ಗೆ.

24
00:01:22,950 --> 00:01:27,180
>> ಆದ್ದರಿಂದ ಅಂತಿಮವಾಗಿ, ನಾವು ಮೌಲ್ಯೀಕರಿಸಲು ಬಯಸುವ
ಎನ್ಕ್ರಿಪ್ಟ್ ಪಾಸ್ವರ್ಡ್ ಬಳಕೆದಾರ

25
00:01:27,180 --> 00:01:30,840
ಪ್ರವೇಶಿಸಿತು ವಾಸ್ತವವಾಗಿ ಸಾಧ್ಯವಿತ್ತು
ಒಂದು ಎನ್ಕ್ರಿಪ್ಟ್ ಪಾಸ್ವರ್ಡ್.

26
00:01:30,840 --> 00:01:35,120
ನೆಲಮಾಳಿಗೆಯ ಮ್ಯಾನ್ ಪುಟವನ್ನು, ಪ್ರತಿ
ಎನ್ಕ್ರಿಪ್ಟ್ ಪಾಸ್ವರ್ಡ್ 13 ಇರಬೇಕು

27
00:01:35,120 --> 00:01:36,440
ದೀರ್ಘ ಪಾತ್ರಗಳು.

28
00:01:36,440 --> 00:01:41,500
ಅಪ್ ಇಲ್ಲಿ, ನಾವು ಹ್ಯಾಶ್ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಗಮನಿಸಿ
13 ಉದ್ದ ಎನ್ಕ್ರಿಪ್ಟ್.

29
00:01:41,500 --> 00:01:46,140
ಆದ್ದರಿಂದ ನಾವು ಖಚಿತವಾಗಿ ಎಂದು ನೀವು ಮಾಡುತ್ತಿರುವಿರಿ
ಎನ್ಕ್ರಿಪ್ಟ್ ಆಫ್ ಸ್ಟ್ರಿಂಗ್ ಉದ್ದ

30
00:01:46,140 --> 00:01:49,090
ಪಾಸ್ವರ್ಡ್ 13.

31
00:01:49,090 --> 00:01:52,280
>> ಇದು ಅಲ್ಲ ವೇಳೆ ಮತ್ತು, ನಾವು ಬಯಸುವ
ಕಾರ್ಯಕ್ರಮದಲ್ಲಿ ನಿರ್ಗಮಿಸಲು.

32
00:01:52,280 --> 00:01:56,470
ಆದ್ದರಿಂದ ಒಮ್ಮೆ ನಾವು ರೀತಿಯಲ್ಲಿ ಮಾಡಬಹುದು ಔಟ್ ಇಲ್ಲಿದೆ
ಈಗ ವಾಸ್ತವವಾಗಿ ಹುಡುಕಲು ಪ್ರಯತ್ನಿಸಿ ಏನು

33
00:01:56,470 --> 00:02:00,410
ಎನ್ಕ್ರಿಪ್ಟ್ ನೀಡಿದ ಪಾಸ್ವರ್ಡ್
ಪಾಸ್ವರ್ಡ್ ಆಗಿತ್ತು.

34
00:02:00,410 --> 00:02:04,870
ಇಲ್ಲಿ, ನಾವು ಉಪ್ಪು ದೋಚಿದ ಬಯಸುವ
ಎನ್ಕ್ರಿಪ್ಟ್ ಪಾಸ್ವರ್ಡ್ ನಿಂದ.

35
00:02:04,870 --> 00:02:08,930
, ಮ್ಯಾನ್ ಪುಟವನ್ನು ಪ್ರತಿ, ನೆನಪಿನಲ್ಲಿಡಿ
ಒಂದು ಎನ್ಕ್ರಿಪ್ಟ್ ಮೊದಲ ಎರಡು ಪಾತ್ರಗಳು

36
00:02:08,930 --> 00:02:10,590
ಸ್ಟ್ರಿಂಗ್, ಇಲ್ಲಿ ಇಷ್ಟ -

37
00:02:10,590 --> 00:02:12,770
50ZPJ ಹೀಗೆ -

38
00:02:12,770 --> 00:02:16,170
ಮೊದಲ ಎರಡು ಪಾತ್ರಗಳು ನೀಡಿ
ನಮಗೆ ಬಳಸಿದ ಉಪ್ಪು

39
00:02:16,170 --> 00:02:18,080
ಸಂಯೋಜಿತಗೊಂಡಿದೆ ಕಾರ್ಯದಲ್ಲಿ.

40
00:02:18,080 --> 00:02:21,740
>> ಇಲ್ಲಿ, ನಾವು ಉಪ್ಪು ಹೆ ಎಂದು ನೋಡಿ.

41
00:02:21,740 --> 00:02:27,610
ಆದ್ದರಿಂದ ನಾವು ಮೊದಲ ಎರಡು ನಕಲಿಸಲು ಬಯಸುವ
ಪಾತ್ರಗಳು, ಉಪ್ಪು ಉದ್ದ ಹ್ಯಾಶ್ ಎಂದು

42
00:02:27,610 --> 00:02:30,230
ಎರಡು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ.

43
00:02:30,230 --> 00:02:35,970
ನಾವು ಮೊದಲ ಎರಡು ಪಾತ್ರಗಳು ನಕಲಿಸಲು ಹೊಂದಿವೆ
ಈ ರಚನೆಯ ಒಳಗೆ, ಉಪ್ಪು.

44
00:02:35,970 --> 00:02:39,340
ನಾವು ಜೊತೆಗೆ ಉಪ್ಪು ಉದ್ದ ಅಗತ್ಯವಿರುವ ಗಮನಿಸಿ
ನಾವು ಇನ್ನೂ ಒಂದು ಶೂನ್ಯ ಬೇಕಾಗುತ್ತದೆ ಒಂದು,

45
00:02:39,340 --> 00:02:42,440
ನಮ್ಮ ಉಪ್ಪು ಕೊನೆಯಲ್ಲಿ ಟರ್ಮಿನೇಟರ್.

46
00:02:42,440 --> 00:02:46,940
>> ನಂತರ ನಾವು, ಈ ಶ್ರೇಣಿಯನ್ನು ಘೋಷಿಸಲು ಹೊರಟಿರುವೆ
ಗಾತ್ರ ಗರಿಷ್ಠ ಉದ್ದದ ಅತಿಥಿ, ಜೊತೆಗೆ

47
00:02:46,940 --> 00:02:51,930
ಗರಿಷ್ಠ ಉದ್ದ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ ಹ್ಯಾಶ್ ಅಲ್ಲಿ ಒಂದು,
ಎಂಟು ಮಾಹಿತಿ, ನಂತರ ಗರಿಷ್ಠ ಪಾಸ್ವರ್ಡ್

48
00:02:51,930 --> 00:02:55,090
ಎಂಟು ಅಕ್ಷರಗಳು ಉದ್ದವಾಗಿದೆ.

49
00:02:55,090 --> 00:02:59,860
ಮತ್ತು ನಾವು ತಿರುಗಿ ಈ ಬಳಸಲು ಹೊರಟಿರುವೆ
ಎಲ್ಲಾ ಸಾಧ್ಯ ತಂತಿಗಳ ಮೇಲೆ ಅದು

50
00:02:59,860 --> 00:03:01,430
ಮಾನ್ಯ ಗುಪ್ತಪದಗಳು.

51
00:03:01,430 --> 00:03:07,720
ಆದ್ದರಿಂದ ಪಾಸ್ವರ್ಡ್ ರಲ್ಲಿ ಮಾನ್ಯ ಪಾತ್ರಗಳು
ನಂತರ ಕೇವಲ ಒಂದು, ಬೌ, ಮತ್ತು ಸಿ, ಎಂದು

52
00:03:07,720 --> 00:03:14,970
ನಾವು, ಒಂದು ಪ್ರತಿ ಬೌ, ಸಿ, ಮರಳಿ ಎಂದು
ಆ, ಬಾ, CA, ಮತ್ತು ಆದ್ದರಿಂದ ಮೇಲಿನ ರವರೆಗೆ

53
00:03:14,970 --> 00:03:16,690
ನಾವು cccccccc ನೋಡಲು ಪಡೆಯಲು -

54
00:03:16,690 --> 00:03:19,600
ಎಂಟು ಸಿ ತಂದೆಯ.

55
00:03:19,600 --> 00:03:23,620
>> ಮತ್ತು ನಾವು ಮಾನ್ಯ ಕೆಳಗೆ ಮಾಡದಿದ್ದಲ್ಲಿ
ಪಾಸ್ವರ್ಡ್, ನಂತರ ನಾವು ಹೇಳಲು ಅಗತ್ಯವಿರುವ

56
00:03:23,620 --> 00:03:26,590
ಎನ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ರಿಂಗ್ ಅಲ್ಲ
ಆರಂಭಿಸಬೇಕು ಮಾನ್ಯ.

57
00:03:26,590 --> 00:03:29,970
ಈಗ, ನಾವು 1 ಲೂಪ್ ಈ ತಲುಪಲು.

58
00:03:29,970 --> 00:03:33,100
ಅದು ಅರ್ಥ ಗಮನಿಸಿ
ಅನಂತ ಆದೇಶಗಳ.

59
00:03:33,100 --> 00:03:36,430
>> ಯಾವುದೇ ಬ್ರೇಕ್ ಹೇಳಿಕೆ ಇವೆ ಗಮನಿಸಿ
ಈ ಅನಂತ ಆದೇಶಗಳ ಒಳಗೆ.

60
00:03:36,430 --> 00:03:38,570
ಕೇವಲ ಹೇಳಿಕೆಗಳನ್ನು ಅಲ್ಲಿ ಮರಳಿ ಮಾಡಲಾಗುತ್ತದೆ.

61
00:03:38,570 --> 00:03:41,210
ಆದ್ದರಿಂದ ನಾವು ವಾಸ್ತವವಾಗಿ ನಿರೀಕ್ಷಿಸಬಹುದು ಇಲ್ಲ
ಲೂಪ್ ನಿರ್ಗಮಿಸಲು.

62
00:03:41,210 --> 00:03:44,750
ನಾವು ಪ್ರೋಗ್ರಾಂ ನಿರ್ಗಮಿಸಲು ನಿರೀಕ್ಷಿಸಬಹುದು.

63
00:03:44,750 --> 00:03:48,220
ನಾನು ಈ ಮುದ್ರಣ ಹೇಳಿಕೆ ಸೇರಿಸಿದ
ಈ ಲೂಪ್ ನ ಮೇಲಿನ ಕೇವಲ ಔಟ್ ಮುದ್ರಿಸಲು

64
00:03:48,220 --> 00:03:51,790
ಎಷ್ಟು ನಮ್ಮ ಪ್ರಸ್ತುತ ಬುದ್ಧಿ
ಯಾವ ಗುಪ್ತಪದವನ್ನು.

65
00:03:51,790 --> 00:03:53,630
>> ಈಗ, ಈ ಲೂಪ್ ಮಾಡುತ್ತಿರುವುದಾದರೂ ಏನು?

66
00:03:53,630 --> 00:03:58,330
ಇದು ಸಾಧ್ಯವಿರುವ ಎಲ್ಲಾ ತಂತಿಗಳನ್ನು ಪ್ರತಿ ಲೂಪಿಂಗ್ ವಿಶೇಷವೇನು
ಎಂದು ಮಾನ್ಯ ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ಆಗಿರಬಹುದು.

67
00:03:58,330 --> 00:04:02,700
ನಾವು ಹೊರಟಿರುವೆ ಮೊದಲ ವಿಷಯ
ನಮ್ಮ ಪ್ರಸ್ತುತ ಬುದ್ಧಿ ತೆಗೆದುಕೊಂಡು ಏನು

68
00:04:02,700 --> 00:04:03,920
ಪಾಸ್ವರ್ಡ್ ಆಗಿದೆ.

69
00:04:03,920 --> 00:04:07,230
ನಾವು ಗಳಿಸಿದರು ಉಪ್ಪು ಕರೆದೊಯ್ಯಲಿದ್ದೇವೆ
ಎನ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ರಿಂಗ್, ಮತ್ತು ನಾವು ನೀವು

70
00:04:07,230 --> 00:04:09,850
ಬುದ್ಧಿ ಎನ್ಕ್ರಿಪ್ಟ್ ಹೋಗಿ.

71
00:04:09,850 --> 00:04:14,760
ಈ, ನಮಗೆ ಒಂದು ಎನ್ಕ್ರಿಪ್ಟ್ ಬುದ್ಧಿ ನೀಡುತ್ತದೆ
ನಾವು ವಿರುದ್ಧ ಹೋಲಿಸಿ ಹೊರಟಿರುವೆ ಇದು

72
00:04:14,760 --> 00:04:18,810
ಎನ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ರಿಂಗ್ ಬಳಕೆದಾರರ
ಆಜ್ಞಾ ಸಾಲಿನಲ್ಲಿ ನಲ್ಲಿ ಪ್ರವೇಶಿಸಿತು.

73
00:04:18,810 --> 00:04:23,030
>> ಅವರು ಅದೇ ಇದ್ದರೆ ಈ ಸಂದರ್ಭದಲ್ಲಿ
ಹೋಲಿಸಬಹುದಾದ ಸ್ಟ್ರಿಂಗ್ ವೇಳೆ ಶೂನ್ಯ ಹಿಂದಿರುಗುವ

74
00:04:23,030 --> 00:04:28,050
ಅವರು ಅದೇ ನೀವು, ಆಗ ಊಹೆ
ಎನ್ಕ್ರಿಪ್ಟ್ ಉತ್ಪಾದಿಸಲ್ಪಡುವ ಪಾಸ್ವರ್ಡ್

75
00:04:28,050 --> 00:04:33,520
ಸ್ಟ್ರಿಂಗ್, ನಾವು ಮುದ್ರಿಸಬಹುದು ಇದು ಸಂದರ್ಭದಲ್ಲಿ
ನಮ್ಮ ಪಾಸ್ವರ್ಡ್ ಮತ್ತು ಹಿಂದಿರುಗಿದ ಎಂದು.

76
00:04:33,520 --> 00:04:37,520
ಆದರೆ ಅದೇ ಒಂದು ವೇಳೆ, ಆ
ನಮ್ಮ ಬುದ್ಧಿ ತಪ್ಪಾಗಿದೆ ಅರ್ಥ.

77
00:04:37,520 --> 00:04:43,250
>> ಮತ್ತು ನಾವು ಮರಳಿ ಬಯಸುವ
ಮುಂದಿನ ಮಾನ್ಯ ಊಹೆ.

78
00:04:43,250 --> 00:04:46,410
ಆದ್ದರಿಂದ ಏನನ್ನು ಈ ಸಂದರ್ಭದಲ್ಲಿ
ಲೂಪ್ ಮಾಡಲು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದಾರೆ.

79
00:04:46,410 --> 00:04:51,760
ಇದು ನಮ್ಮ ಬುದ್ಧಿ ಹೇಳು ಹೋಗುತ್ತೇನೆಂದು
ಮುಂದಿನ ಮಾನ್ಯ ಊಹೆಯನ್ನು ಮಾಡಲು.

80
00:04:51,760 --> 00:04:56,080
ನಾವು ಹೇಳಲು ಆ ಗಮನಿಸಿ ಒಂದು
ನಮ್ಮ ಬುದ್ಧಿ ನಿರ್ದಿಷ್ಟ ರ ಹೊಂದಿದೆ

81
00:04:56,080 --> 00:05:01,770
ಇದು ಅಪ್ ಇಲ್ಲಿ ಗರಿಷ್ಠ ಸಂಕೇತ, ತಲುಪಿದ್ದೀರಿ
ಹ್ಯಾಶ್ ರಿಂದ, ಒಂದು tilde ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ

82
00:05:01,770 --> 00:05:05,710
ಎಂದು ದೊಡ್ಡ ASCII ಮೌಲ್ಯವನ್ನು ಪಾತ್ರದ
ಒಂದು ಬಳಕೆದಾರ ನಲ್ಲಿ ನಮೂದಿಸಬಹುದು ಎಂದು

83
00:05:05,710 --> 00:05:11,210
ಕೀಬೋರ್ಡ್, ಯಾವಾಗ ರ ತಲುಪುತ್ತದೆ
ಗರಿಷ್ಠ ಸಂಕೇತ, ನಂತರ ನಾವು ಕಳುಹಿಸಲು ಬಯಸುವ

84
00:05:11,210 --> 00:05:17,150
ಇದು, ಕನಿಷ್ಠ ಚಿಹ್ನೆ ಹಿಂದಕ್ಕೆ ಇದು
ಮತ್ತೆ, ಕಡಿಮೆ ಮಾಡಿದ ASCII ಒಂದು ಜಾಗಗಳನ್ನು

85
00:05:17,150 --> 00:05:20,800
ಮೌಲ್ಯದ ಸಂಕೇತವಾಗಿ ಒಂದು ಬಳಕೆದಾರ ಮಾಡಬಹುದು
ಕೀಬೋರ್ಡ್ ನಲ್ಲಿ ನಮೂದಿಸಿ.

86
00:05:20,800 --> 00:05:22,940
>> ಆದ್ದರಿಂದ ನಾವು ಸೆಟ್ ಹೊರಟಿರುವೆ
ಕನಿಷ್ಠ ಚಿಹ್ನೆ.

87
00:05:22,940 --> 00:05:25,720
ತದನಂತರ ನಾವು ಹೋಗಿ ಹೊರಟಿರುವೆ
ಮುಂದಿನ ಅಕ್ಷರಕ್ಕೆ ಮೇಲೆ.

88
00:05:25,720 --> 00:05:28,730
ಆದ್ದರಿಂದ ಹೇಗೆ ನಮ್ಮ ಊಹೆಗಳು
ಮರಳಿ ಹೋಗಿ?

89
00:05:28,730 --> 00:05:33,685
ವೆಲ್, ಮಾನ್ಯ ಪಾತ್ರಗಳು, ಒಂದು, ಬೌ ವೇಳೆ
ಮತ್ತು ಸಿ, ನಂತರ ನಾವು, ಒಂದು ಪ್ರಾರಂಭವಾಯಿತು ವೇಳೆ

90
00:05:33,685 --> 00:05:36,630
ಇದು ಬೌ ಗೆ ಮರಳಿ ಮಾಡುತ್ತೇವೆ, ಇದು ಮಾಡುತ್ತೇವೆ
ಸಿ ಗೆ ಮರಳಿ.

91
00:05:36,630 --> 00:05:44,360
ಸಿ ನಮ್ಮ ಗರಿಷ್ಠ ಸಂಕೇತವಾಗಿದೆ, ಆದ್ದರಿಂದ ನಾವು ಸೆಟ್ ಮಾಡುತ್ತೇವೆ
ಒಂದು ಮರಳಿ ಸಿ, ಕನಿಷ್ಠ ಚಿಹ್ನೆ.

92
00:05:44,360 --> 00:05:48,100
ತದನಂತರ ನಾವು ಸೂಚ್ಯಂಕ ಮರಳಿ ಮಾಡುತ್ತೇವೆ
ಮುಂದಿನ ಅಕ್ಷರಕ್ಕೆ.

93
00:05:48,100 --> 00:05:53,920
>> ಮೂಲ ಬುದ್ಧಿ ಸಿ, ಮುಂದಿನ ಆಗಿತ್ತು ಆದ್ದರಿಂದ
ಮೀ ಶೂನ್ಯ ಎಂದು ನಾನು

94
00:05:53,920 --> 00:05:55,560
ಟರ್ಮಿನೇಟರ್.

95
00:05:55,560 --> 00:06:00,670
ಡೌನ್ ಇಲ್ಲಿ, ಗಮನಕ್ಕೆ ಎಂದು ವೇಳೆ ರ
ನಾವು ಈಗ ಬಯಸುವ

96
00:06:00,670 --> 00:06:04,690
ಹೆಚ್ಚುವರಿ, ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್ ಆಗಿತ್ತು
ನಂತರ ನಾವು ಅದನ್ನು ಹೊಂದಿಸಲು ಹೊರಟಿರುವೆ

97
00:06:04,690 --> 00:06:06,260
ಕನಿಷ್ಠ ಚಿಹ್ನೆ.

98
00:06:06,260 --> 00:06:11,431
ಬುದ್ಧಿ ನಂತರ, ಸಿ ಎಂದು ಆದ್ದರಿಂದ ನಮ್ಮ
ಹೊಸ ಊಹೆ ಆ ಎಂದು ನಾನು.

99
00:06:11,431 --> 00:06:16,050
ಮತ್ತು ನಮ್ಮ ಮೂಲ ಬುದ್ಧಿ ವೇಳೆ
ನಂತರ cccc, ನಮ್ಮ ಹೊಸ ಬುದ್ಧಿ

100
00:06:16,050 --> 00:06:18,380
aaaaa ಎಂದು ನಾನು.

101
00:06:18,380 --> 00:06:24,430
>> ಆದ್ದರಿಂದ ಬಂದ ನಾವು ಗರಿಷ್ಠ ಸ್ಟ್ರಿಂಗ್ ತಲುಪಲು
ಒಂದು ನಿರ್ದಿಷ್ಟ ಉದ್ದದ, ನಂತರ ನಾವು ನೀವು

102
00:06:24,430 --> 00:06:29,090
ಕನಿಷ್ಠ ಸ್ಟ್ರಿಂಗ್ ಗೆ ಜಾರಿಗೆ ಹೋಗಿ
ಮುಂದಿನ ಉದ್ದದ, ಇದು ತಿನ್ನುವೆ

103
00:06:29,090 --> 00:06:34,420
ಕೇವಲ ಎಲ್ಲಾ ಪಾತ್ರಗಳ ಎಂದು
ಕನಿಷ್ಠ ಚಿಹ್ನೆ.

104
00:06:34,420 --> 00:06:36,970
ಈಗ, ಈ ಚೆಕ್ ಇಲ್ಲಿ ಮಾಡುತ್ತಿರುವುದಾದರೂ ಏನು?

105
00:06:36,970 --> 00:06:42,780
ಸರಿ, ಒಂದು ವೇಳೆ ಸೂಚ್ಯಂಕ ಎಂಟನೇ ಸ್ಥಳಾಂತರಿಸಿ
ಒಂಬತ್ತು ರ ಪಾತ್ರವನ್ನು -

106
00:06:42,780 --> 00:06:46,460
ಆದ್ದರಿಂದ ನಾವು ಎಂಟು ಸಿ ತಂದೆಯ ಮಾಹಿತಿ ಸೇರಿಸಿ
ಊಹೆ ನಮ್ಮ ಹಿಂದಿನ -

107
00:06:46,460 --> 00:06:51,270
ನಂತರ ಸೂಚ್ಯಂಕ ಗಮನ ಹೋಗುವ ಇದೆ
ನಮ್ಮ ಬುದ್ಧಿ ಕೊನೆಯ ಶೂನ್ಯ ಟರ್ಮಿನೇಟರ್

108
00:06:51,270 --> 00:06:57,990
ವಾಸ್ತವವಾಗಿ ಉದ್ದೇಶವನ್ನು ಇದರಲ್ಲಿ ರಚನೆಯ
ನಮ್ಮ ಪಾಸ್ವರ್ಡ್ ಬಳಸಲಾಗುತ್ತದೆ.

109
00:06:57,990 --> 00:07:03,530
>> ನಾವು ಕಳೆದ ಶೂನ್ಯ ಕೇಂದ್ರೀಕರಿಸಿ ಆದ್ದರಿಂದ
ಟರ್ಮಿನೇಟರ್, ನಂತರ ನಾವು ಒಂದು ಕಂಡುಬಂದಿಲ್ಲ

110
00:07:03,530 --> 00:07:07,750
ಮಾನ್ಯ ಕೇವಲ ಎಂಟು ಬಳಸಿಕೊಂಡು ವಿಶೇಷವೇನು ಪಾಸ್ವರ್ಡ್
ಯಾವುದೇ ಅಂದರೆ ಪಾತ್ರಗಳು,

111
00:07:07,750 --> 00:07:10,550
ಎನ್ಕ್ರಿಪ್ಟ್ ಎಂದು ಮಾನ್ಯ ಪಾಸ್ವರ್ಡ್
ಕೊಟ್ಟಿರುವ ಸಾಲನ್ನು ಮಾಡಲು.

112
00:07:10,550 --> 00:07:13,520
ಮತ್ತು ನಾವು ಹೇಳುವ ಮುದ್ರಿಸುವ ಮಾಡಬೇಕು
ನಾವು ಮಾನ್ಯ ಸಿಗಲಿಲ್ಲ

113
00:07:13,520 --> 00:07:16,100
ಪಾಸ್ವರ್ಡ್, ಮತ್ತು ಪ್ರತಿಯಾಗಿ.

114
00:07:16,100 --> 00:07:20,280
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ ಲೂಪ್ ಮರಳಿ ಹೋಗುವ ಇದೆ
ಸಾಧ್ಯವಿರುವ ಎಲ್ಲಾ ತಂತಿಗಳನ್ನು ಪ್ರತಿ.

115
00:07:20,280 --> 00:07:24,640
>> ಇದು ಕಂಡುಕೊಳ್ಳುತ್ತದೆ ವೇಳೆ ಯಾವುದೇ ಎನ್ಕ್ರಿಪ್ಟ್ ಎಂದು
ನಿರೀಕ್ಷಿತ ಎನ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ರಿಂಗ್, ಇದು ಮಾಡುತ್ತೇವೆ

116
00:07:24,640 --> 00:07:26,190
ಪಾಸ್ವರ್ಡ್ ಮರಳಿ.

117
00:07:26,190 --> 00:07:29,610
ಮತ್ತು ಅದು ನಂತರ, ಏನು ಕಾಣಲಿಲ್ಲ
ಇದು ಮುದ್ರಣ, ಹಿಂದಿರುಗುವ ಅದು

118
00:07:29,610 --> 00:07:31,910
ಏನು ಕಂಡುಹಿಡಿಯಲು ಸಾಧ್ಯವಾಗಲಿಲ್ಲ.

119
00:07:31,910 --> 00:07:39,220
ಈಗ, ಗಮನಕ್ಕೆ ಎಲ್ಲ ಪ್ರತಿ iterating
ಸಂಭವನೀಯ ತಂತಿಗಳನ್ನು ಬಹುಶಃ ನಾನು

120
00:07:39,220 --> 00:07:40,420
ಒಂದು ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

121
00:07:40,420 --> 00:07:43,590
ಲೆಟ್ಸ್ ವಾಸ್ತವವಾಗಿ ನೋಡಿ ಹೇಗೆ
ದೀರ್ಘ ಎಂದು ತೆಗೆದುಕೊಳ್ಳುತ್ತದೆ.

122
00:07:43,590 --> 00:07:47,230
>> ತಂದೆಯ ಬಿರುಕು ಮಾಡೋಣ.

123
00:07:47,230 --> 00:07:51,050
ವೆಲ್, ಓಹ್ - ಇದು ಸ್ಪಷ್ಟೀಕರಿಸದ ಹೇಳುತ್ತಾರೆ
ಸಂಯೋಜಿತಗೊಂಡಿದೆ ಉಲ್ಲೇಖವಿದೆ.

124
00:07:51,050 --> 00:07:55,330
ಪು ವಿಶೇಷ ಹೊಂದಿಸುತ್ತದೆ ಮತ್ತು ಆದ್ದರಿಂದ, ಮರೆಯದಿರಿ
ಸಂಯೋಜಿತಗೊಂಡಿದೆ ಸಹ ಮನುಷ್ಯ ಪುಟ ನಾವು

125
00:07:55,330 --> 00:07:58,130
ಲಿಪಿಯಲ್ಲಿ ಲಿಂಕ್ ಮಾಡಬೇಕಾಗುತ್ತದೆ.

126
00:07:58,130 --> 00:08:01,130
ಈಗ, ಡೀಫಾಲ್ಟ್ ಆಜ್ಞೆಯನ್ನು ಮಾಡಲು
ಗೊತ್ತಿಲ್ಲ ಎಂದು ನೀವು

127
00:08:01,130 --> 00:08:03,010
ಆ ಕಾರ್ಯವನ್ನು ಬಳಸಲು ಬಯಸುವ.

128
00:08:03,010 --> 00:08:09,680
>> ಆದ್ದರಿಂದ ನಾವು ಈ ಕ್ಲೈಂಟ್ ಆಜ್ಞೆಯನ್ನು ನಕಲಿಸಿ
ಮತ್ತು ಕೇವಲ ಅಂತ್ಯ ಮೇಲೆ ಸೇರಿಸಿ

129
00:08:09,680 --> 00:08:13,300
ಇದರ, ಲಿಂಕ್ ಸಂಯೋಜಿತಗೊಂಡಿದೆ.

130
00:08:13,300 --> 00:08:14,820
ಈಗ, ಇದು ಸಂಗ್ರಹಿಸುತ್ತಾ.

131
00:08:14,820 --> 00:08:23,880
ಆದ್ದರಿಂದ ನಾವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಮೇಲೆ ಕ್ರ್ಯಾಕ್ ಔಟ್
ಎನ್ಕ್ರಿಪ್ಟ್ ಸ್ಟ್ರಿಂಗ್ -

132
00:08:23,880 --> 00:08:25,130
ಸೀಸರ್ ನ ಹಾಗೆ.

133
00:08:25,130 --> 00:08:28,690

134
00:08:28,690 --> 00:08:30,790
ಆದ್ದರಿಂದ ಬಹಳ ವೇಗವಾಗಿ ಆಗಿತ್ತು.

135
00:08:30,790 --> 00:08:33,230
>> ಈ 13 ರಂದು ಕೊನೆಗೊಂಡಿತು ಗಮನಿಸಿ.

136
00:08:33,230 --> 00:08:38,240
ವೆಲ್, ಸೀಸರ್ ನ ಎನ್ಕ್ರಿಪ್ಟ್ ಪಾಸ್ವರ್ಡ್
13 ನಡೆಯುತ್ತದೆ.

137
00:08:38,240 --> 00:08:41,650
ಆದ್ದರಿಂದ ಅವರ ಇನ್ನೊಂದು ಪಾಸ್ವರ್ಡ್ ಪ್ರಯತ್ನಿಸೋಣ.

138
00:08:41,650 --> 00:08:45,830
ತಂದೆಯ ಹಿರ್ಸ್ಚೋರ್ನ್ ತಂದೆಯ ಎನ್ಕ್ರಿಪ್ಟ್ ತೆಗೆದುಕೊಳ್ಳೋಣ
ಪಾಸ್ವರ್ಡ್ ಮತ್ತು ಬಿರುಕುಗಳು ಪ್ರಯತ್ನಿಸಿ.

139
00:08:45,830 --> 00:08:51,750

140
00:08:51,750 --> 00:08:55,110
>> ನಾವು ಈಗಾಗಲೇ ತಲುಪಿದ್ದೀರಿ ಆದ್ದರಿಂದ ಗಮನಕ್ಕೆ
ಮೂರು ಪಾತ್ರಗಳು.

141
00:08:55,110 --> 00:08:58,660
ಮತ್ತು ನಾವು ಎಲ್ಲಾ ಸಂಭಾವ್ಯ ಪ್ರತಿ iterating ನೀವು
ಮೂರು ರ ತಂತಿಗಳು.

142
00:08:58,660 --> 00:09:01,420
ನಮಗೆ ಈಗಾಗಲೇ ಪೂರ್ಣಗೊಳಿಸಲು ನಾವು ಅರ್ಥ
ಎಲ್ಲಾ ಸಂಭಾವ್ಯ ಒಂದು ಪ್ರತಿ iterating ಮತ್ತು

143
00:09:01,420 --> 00:09:04,660
ಎರಡು ರ ತಂತಿಗಳು.

144
00:09:04,660 --> 00:09:09,180
ಈ ನಾನು ಹಾಗೆ ಈಗ, ಇದು ಕಾಣುತ್ತದೆ
ನಾವು ತಲುಪುವ ಮುನ್ನ ಸ್ವಲ್ಪ ಸಮಯ ತೆಗೆದುಕೊಳ್ಳಬಹುದು

145
00:09:09,180 --> 00:09:10,580
ನಾಲ್ಕು ರ ತಂತಿಗಳು.

146
00:09:10,580 --> 00:09:14,680
ಇದು ಒಂದೆರಡು ನಿಮಿಷಗಳ ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

147
00:09:14,680 --> 00:09:16,055
>> ಇದು ನಿಮಿಷಕ್ಕೂ ಬರಲಿಲ್ಲ.

148
00:09:16,055 --> 00:09:18,450
ನಾವು ನಾಲ್ಕು ರ ತಂತಿಗಳನ್ನು ಇದ್ದೇವೆ.

149
00:09:18,450 --> 00:09:22,800
ಆದರೆ ಈಗ, ನಾವು ಎಲ್ಲಾ ಪ್ರತಿ ಮರಳಿ ಅಗತ್ಯವಿದೆ
ಸಂಭವನೀಯ ನಾಲ್ಕು ರ ತಂತಿಗಳು ಇದು

150
00:09:22,800 --> 00:09:26,000
ಎಂದು ಬಹುಶಃ 10 ನಿಮಿಷಗಳನ್ನು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

151
00:09:26,000 --> 00:09:28,720
ತದನಂತರ ನಾವು ಐದು ಮೀ ತಲುಪಿದಾಗ
ತಂತಿ, ನಾವು ಎಲ್ಲಾ ಪ್ರತಿ ಮರಳಿ ಅಗತ್ಯವಿದೆ

152
00:09:28,720 --> 00:09:31,450
ಆ, ಇದು ಮಾಡಬಹುದು
ಒಂದೆರಡು ಗಂಟೆಗಳು ತೆಗೆದುಕೊಳ್ಳಬಹುದು.

153
00:09:31,450 --> 00:09:34,080
ಮತ್ತು ನಾವು ಎಲ್ಲಾ ಸಂಭಾವ್ಯ ಪ್ರತಿ ಮರಳಿ ಅಗತ್ಯವಿದೆ
ಆರು ರ ತಂತಿಗಳು ಇದು

154
00:09:34,080 --> 00:09:36,560
ಹೀಗೆ ಒಂದೆರಡು ದಿನಗಳ ತೆಗೆದುಕೊಂಡು ಇರಬಹುದು.

155
00:09:36,560 --> 00:09:41,380
>> ಆದ್ದರಿಂದ ಇದು ಬಹಳ ಪ್ರಬಲವಾಗಿ ತೆಗೆದುಕೊಳ್ಳಬಹುದು
ಎಲ್ಲಾ ಸಂಭಾವ್ಯ ಪ್ರತಿ ಮರಳಿ ಸಮಯ

156
00:09:41,380 --> 00:09:44,850
ಎಂಟು ರ ಮತ್ತು ಕಡಿಮೆ ತಂತಿಗಳು.

157
00:09:44,850 --> 00:09:50,600
ಆದ್ದರಿಂದ ಈ ಒಂದು ಎಂದೇನೂ ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಗಮನಕ್ಕೆ
ಕಂಡು ತುಂಬಾ ಪರಿಣಾಮಕಾರಿ ಕ್ರಮಾವಳಿ

158
00:09:50,600 --> 00:09:51,860
ಒಂದು ಪಾಸ್ವರ್ಡ್.

159
00:09:51,860 --> 00:09:54,540
ನೀವು ಆಲೋಚಿಸುತ್ತೀರಿ ಎಂದು ಅಲ್ಲಿ
ಉತ್ತಮ ವಿಧಾನಗಳಿವೆ.

160
00:09:54,540 --> 00:10:02,230
ಉದಾಹರಣೆಗೆ, ಪಾಸ್ವರ್ಡ್ zyx! 32ab
ಪ್ರಾಯಶಃ ಬಹಳ ಸಾಮಾನ್ಯ ಪಾಸ್ವರ್ಡ್ ಅಲ್ಲ

161
00:10:02,230 --> 00:10:06,440
12345 ಪಾಸ್ವರ್ಡ್ ಆದರೆ
ಬಹುಶಃ ಹೆಚ್ಚು ಬಹಳಷ್ಟು ಸಾಮಾನ್ಯ.

162
00:10:06,440 --> 00:10:13,570
>> ಪಾಸ್ವರ್ಡ್ ಹೇಗೆ ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಆದ್ದರಿಂದ ಒಂದು ರೀತಿಯಲ್ಲಿ
ಹೆಚ್ಚು ವೇಗವಾಗಿ ಕೇವಲ ನೋಡಲು ಆಗಿದೆ

163
00:10:13,570 --> 00:10:15,560
ಹೆಚ್ಚು ಸಾಮಾನ್ಯವಾಗಿರುವ ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ನಲ್ಲಿ.

164
00:10:15,560 --> 00:10:20,480
ಆದ್ದರಿಂದ ಉದಾಹರಣೆಗೆ, ನಾವು ಪದಗಳನ್ನು ಓದಲು ಪ್ರಯತ್ನಿಸಬಹುದು
ಒಂದು ನಿಘಂಟು ಮತ್ತು ಎಲ್ಲಾ ಪ್ರಯತ್ನಿಸಿ

165
00:10:20,480 --> 00:10:24,860
ನಮ್ಮ ಪಾಸ್ವರ್ಡ್ ಊಹೆಗಳು ಮಾಹಿತಿ ಪದಗಳಾಗಿ.

166
00:10:24,860 --> 00:10:29,210
ಈಗ, ಬಹುಶಃ ಒಂದು ಗುಪ್ತಪದವನ್ನು
ಸರಳ ಅಲ್ಲ.

167
00:10:29,210 --> 00:10:32,600
ಬಹುಶಃ ಬಳಕೆದಾರ ಸ್ವಲ್ಪ ಬುದ್ಧಿವಂತ ಆಗಿತ್ತು
ಮತ್ತು ಒಂದು ಸಂಖ್ಯೆಯನ್ನು ಸೇರಿಸುವುದರಿಂದ ಪ್ರಯತ್ನಿಸಿ

168
00:10:32,600 --> 00:10:34,220
ಒಂದು ಪದದ ಕೊನೆಯಲ್ಲಿ.

169
00:10:34,220 --> 00:10:37,000
>> ಆದ್ದರಿಂದ ಬಹುಶಃ ತಮ್ಮ ಪಾಸ್ವರ್ಡ್ password1 ಆಗಿತ್ತು.

170
00:10:37,000 --> 00:10:41,520
ಆದ್ದರಿಂದ ನೀವು ಎಲ್ಲಾ ಪದಗಳ ಮೇಲೆ iterating ಪ್ರಯತ್ನಿಸಬಹುದು
ಒಂದು ಜೊತೆ ನಿಘಂಟಿನಲ್ಲಿ

171
00:10:41,520 --> 00:10:43,210
ಇದು ಕೊನೆಯಲ್ಲಿ ಸೇರಿಸಲಾಗಿದೆ.

172
00:10:43,210 --> 00:10:47,360
ತದನಂತರ ಬಹುಶಃ ಆ ನಡೆಸಿದ ನಂತರ, ನೀವು ಮಾಡುತ್ತೇವೆ
ಇದು ಕೊನೆಯಲ್ಲಿ ಒಂದು ಎರಡು ಸೇರಿಸಿಕೊಳ್ಳುತ್ತವೆ.

173
00:10:47,360 --> 00:10:50,240
>> ಅಥವಾ ಬಹುಶಃ ಬಳಕೆದಾರ ಸಹ ಎಂದು ಪ್ರಯತ್ನಿಸುತ್ತಿದ್ದಾರೆ
ಹೆಚ್ಚು ಬುದ್ಧಿವಂತ, ಮತ್ತು ಅವರು ಬಯಸುವ ತಮ್ಮ

174
00:10:50,240 --> 00:10:54,980
ಪಾಸ್ವರ್ಡ್ ", ಹ್ಯಾಕರ್" ಎಂದು ಆದರೆ ಅವರು ಕೋರುತ್ತೇವೆ
ಇ ನ ಎಲ್ಲಾ ನಿದರ್ಶನಗಳನ್ನು ಬದಲಿಗೆ ಹೋಗಿ

175
00:10:54,980 --> 00:10:56,600
ಮೂರುಗಳು ಜೊತೆ.

176
00:10:56,600 --> 00:10:58,440
ಆದ್ದರಿಂದ ನೀವು ತುಂಬಾ ಈ ಮಾಡಬಲ್ಲರು.

177
00:10:58,440 --> 00:11:02,100
ನಿಘಂಟು ಎಲ್ಲ ಪದಗಳನ್ನು ಪ್ರತಿ ತಿರುಗಿ
ಆದರೆ ಅಕ್ಷರಗಳ ಬದಲಿಗೆ

178
00:11:02,100 --> 00:11:04,790
ಆ ಸಂಖ್ಯೆಯ ಸಂಖ್ಯೆಗಳನ್ನು ರೀತಿ.

179
00:11:04,790 --> 00:11:09,670
>> ಈ ರೀತಿಯಲ್ಲಿ, ಆದ್ದರಿಂದ ನೀವು ಇನ್ನೂ ದಾಳಿಯಾಗಬಹುದು
ಸಾಕಷ್ಟು ಸಾಮಾನ್ಯ ಎಂದು ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು.

180
00:11:09,670 --> 00:11:14,690
ಆದರೆ ಕೊನೆಯಲ್ಲಿ, ಕೇವಲ ರೀತಿಯಲ್ಲಿ ನೀವು
ಎಲ್ಲ ಪಾಸ್ವರ್ಡ್ಗಳನ್ನು ಹಿಡಿಯಲು ವಿವೇಚನಾರಹಿತ ಮಾಡುವುದು

181
00:11:14,690 --> 00:11:17,340
ಎಲ್ಲಾ ಪ್ರತಿ ತಿರುಗಿ ಒತ್ತಾಯಿಸಲು
ಸಂಭವನೀಯ ತಂತಿಗಳು.

182
00:11:17,340 --> 00:11:22,100
ಆದ್ದರಿಂದ ಕೊನೆಯಲ್ಲಿ, ನೀವು ಮರಳಿ ಗೆ ಅಗತ್ಯವೇನು
ಒಂದು ಮೀ ರಿಂದ ಎಲ್ಲಾ ತಂತಿಗಳನ್ನು ಪ್ರತಿ

183
00:11:22,100 --> 00:11:28,110
ಒಂದು ತೆಗೆದುಕೊಳ್ಳಬಹುದು ಇದು ಎಂಟು ಪಾತ್ರಗಳು,
ಬಹಳ ಸಮಯ, ಆದರೆ ನೀವು ಅದನ್ನು ಅಗತ್ಯ.

184
00:11:28,110 --> 00:11:30,024
>> ನನ್ನ ಹೆಸರು ರಾಬ್ ಬೌಡೆನ್ ಆಗಿದೆ.

185
00:11:30,024 --> 00:11:31,425
ಮತ್ತು ಈ ಕ್ರ್ಯಾಕ್ ಆಗಿದೆ.

186
00:11:31,425 --> 00:11:36,533