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