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