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