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