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