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