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