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