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