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