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