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