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