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