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