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