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