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