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