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