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