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