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