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