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