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