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