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