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