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